format only if server provides formatting

nvim/.config/nvim/fnl/dotfiles/core.fnl

@@ -1,124 +1,115 @@
-(module dotfiles.core
+(module dotfiles.core {autoload {a aniseed.core}
-  {autoload
+                       require {anenv aniseed.env
-   {a aniseed.core}
+                                nvim aniseed.nvim
-   require
+                                nu aniseed.nvim.util
-   {anenv aniseed.env
+                                u dotfiles.util}})
-    nvim aniseed.nvim
-    nu aniseed.nvim.util
-    u dotfiles.util
-    }})
 
+(nvim.ex.set :shortmess+=c)
 
-(nvim.ex.set "shortmess+=c") ; don't give |ins-completion-menu| messages.
+; don't give |ins-completion-menu| messages.
-(nvim.ex.set "path+=**")
+(nvim.ex.set :path+=**)
 (nvim.ex.set "wildignore+=*.o,*.obj,.git,*.rbc,*.class,.svn,vendor/gems/*")
 
-(defn- safe-source
+(defn- safe-source [filename]
-  [filename]
+       (let [glob (nvim.fn.glob filename)]
-  (let [glob (nvim.fn.glob filename)]
+         (if (not (a.empty? glob))
-    (if (not (a.empty? glob))
+             (nvim.ex.source filename))))
-      (nvim.ex.source filename))))
 
 ; (a.map safe-source ["~/.vimrc" "~/.vimrc.local"])
 
-(def- backup-dir (.. (nvim.fn.glob "$HOME") "/.vim/backup"))
+(def- backup-dir (.. (nvim.fn.glob :$HOME) :/.vim/backup))
-(def- undo-dir (.. (nvim.fn.glob "$HOME") "/.vim/backup"))
+(def- undo-dir (.. (nvim.fn.glob :$HOME) :/.vim/backup))
 
-(def- on-opts [
+(def- on-opts [:autoindent
-           :autoindent
+               :autoread
-           :autoread
+               :expandtab
-           :expandtab
+               :exrc
-           :exrc ; allow project level (neo)vim files
+               ; allow project level (neo)vim files
-           :hlsearch
+               :hlsearch
-           :ignorecase
+               :ignorecase
-           :incsearch
+               :incsearch
-           :number
+               :number
-           :ruler
+               :ruler
-           :secure
+               :secure
-           :shiftround ; When at 3 spaces and I hit >>, go to 4, not 5.
+               :shiftround
-           :showcmd ; shows (parital) command in the status line
+               ; When at 3 spaces and I hit >>, go to 4, not 5.
-           :showmatch
+               :showcmd
-           :smartcase
+               ; shows (parital) command in the status line
-           :splitbelow
+               :showmatch
-           :splitright
+               :smartcase
-           :termguicolors
+               :splitbelow
-           :title
+               :splitright
-           :undofile
+               :termguicolors
-           :wildmenu
+               :title
-           ])
+               :undofile
+               :wildmenu])
 
+(def- val-based-opts {; :t_Co 256
+                      :laststatus 2
+                      :encoding :utf-8
+                      :history 500
+                      :redrawtime 5000
+                      :scrolloff 3
+                      :guifont :Hasklig
+                      :guifontwide :Hasklig
+                      :background :dark
+                      :backupdir backup-dir
+                      :directory backup-dir
+                      ;Don't clutter my dirs up with swp and tmp files
+                      :grepprg "ag --vimgrep"
+                      ; Use Silver Searcher instead of grep
+                      :tags :tags
+                      :updatetime 300
+                      ; per coc.vim for diagnostic messages
+                      :signcolumn "auto:1-3"
+                      :colorcolumn [80 100]
+                      :cmdheight 2
+                      ; Better display for messages
+                      :undodir undo-dir
+                      :undolevels 1000
+                      :undoreload 10000
+                      :foldmethod :expr
+                      :foldexpr "nvim_treesitter#foldexpr()"
+                      :foldlevelstart 100
+                      :foldlevel 99
+                      :tabstop 2
+                      :shiftwidth 2
+                      :softtabstop 2
+                      :mouse ""
+                      :list true
+                      :listchars "tab:➥\\ ,trail:·,"
+                      :backspace "indent,eol,start"
+                      ;allow backspacing over everything in insert mode
+                      :wildmode "list:longest,list:full"
+                      :wrap false})
 
-(def- val-based-opts
+(defn- set-opt [[opt val]] (tset vim.opt (a.str opt) val))
-  {
-   ; :t_Co 256
-   :laststatus 2
-   :encoding "utf-8"
-   :history 500
-   :redrawtime 5000
-   :scrolloff 3
-   :guifont "Hasklig"
-   :background "dark"
-   :backupdir backup-dir
-   :directory backup-dir      ;Don't clutter my dirs up with swp and tmp files
-   :grepprg "ag --vimgrep" ; Use Silver Searcher instead of grep
-   :tags "tags"
-   :updatetime 300 ; per coc.vim for diagnostic messages
-   :signcolumn "auto:1-3"
-   :colorcolumn [80 100]
-   :cmdheight 2 ; Better display for messages
-   :undodir undo-dir
-   :undolevels 1000
-   :undoreload 10000
-   :foldmethod "expr"
-   :foldexpr "nvim_treesitter#foldexpr()"
-   :foldlevelstart 100
-   :foldlevel 99
-   :tabstop 2
-   :shiftwidth 2
-   :softtabstop 2
-   :mouse ""
-   :list true
-   :listchars "tab:➥\\ ,trail:·,"
-   :backspace "indent,eol,start"    ;allow backspacing over everything in insert mode
-   :wildmode "list:longest,list:full"
-   :wrap false
-   })
 
-(defn- set-opt
+(defn- set-opt-on [opt] (set-opt [opt true]))
-  [[opt val]]
-  (tset vim.opt (a.str opt) val))
-
-(defn- set-opt-on
-  [opt]
-  (set-opt [opt true]))
 
 (a.map set-opt-on on-opts)
 
 (a.map-indexed set-opt val-based-opts)
 
-(nvim.ex.syntax "on")
+(nvim.ex.syntax :on)
 ;; (nvim.ex.colorscheme :soluarized)
- (nvim.ex.colorscheme :solarized8)
+(nvim.ex.colorscheme :solarized8)
-
-
 
 ;; (nvim.ex.autocmd "vimenter" "*" "++nested" "colorscheme" "soluarized")
-(nvim.ex.autocmd "vimenter" "*" "++nested" "colorscheme" "solarized8")
+(nvim.ex.autocmd :vimenter "*" :++nested :colorscheme :solarized8)
 ;(nvim.ex.autocmd "vimenter" "*"  "luafile" "treesitter.lua")
 ;
 ; (nvim.fn.glob "~/.vimrc.local")
 
-(defn make-fennel-scratch
+(defn make-fennel-scratch []
-  []
+      (nvim.command "new | setlocal bt=nofile bh=wipe nobl noswapfile nu filetype=fennel"))
-  (nvim.command "new | setlocal bt=nofile bh=wipe nobl noswapfile nu filetype=fennel"))
+
+(nu.fn-bridge :FennelScratchBuffer :dotfiles.core :make-fennel-scratch
+              {:return false})
 
-(nu.fn-bridge :FennelScratchBuffer :dotfiles.core :make-fennel-scratch {:return false})
 (u.nnoremap :<leader>fsb ":call FennelScratchBuffer ()<CR>")
 
-(defn compile-fnl []
+(defn compile-fnl [] (print :recompiling)
-  (print :recompiling)
+      (anenv.init {:force true :init :dotfiles.init}))
-  (anenv.init
-    {:force true
-     :init :dotfiles.init}))
 
 (nu.fn-bridge :AniseedCompile :dotfiles.core :compile-fnl {:return false})

nvim/.config/nvim/fnl/dotfiles/mapping.fnl

@@ -10,10 +10,11 @@
 ; (set nvim.g.mapleader "\\")
 
 (defn aniseed-reload []
-  (each [k _ (ipairs package.loaded)]
+      (each [k _ (ipairs package.loaded)]
-    (when (string.match k "^dotfiles%..+")
+        (when (string.match k "^dotfiles%..+")
-      (tset package.loaded k nil)))
+          (tset package.loaded k nil)))
-  ((. (require :aniseed.env) :init) {:module :dotfiles.init :compile true}))
+      ((. (require :aniseed.env) :init) {:module :dotfiles.init :compile true})
+      (a.println "aniseed reloaded!"))
 
 (vim.keymap.set :n "<leader>`" aniseed-reload)
 

nvim/.config/nvim/fnl/dotfiles/plugin/lspconfig.fnl

@@ -117,7 +117,8 @@
       ; --   buf_set_keymap('x', '<leader>ic', "<cmd>lua vim.lsp.buf.incoming_calls()<CR>", opts)
       (nvim.buf_set_option 0 :omnifunc "v:lua.vim.lsp.omnifunc")
       (bind-client-mappings client)
-      (nvim.ex.autocmd :BufWritePre :<buffer> :lua :vim.lsp.buf.format)
+      (if client.server_capabilities.documentFormattingProvider
+          (nvim.ex.autocmd :BufWritePre :<buffer> ":lua vim.lsp.buf.format()"))
       ;  (nvim.ex.autocmd "BufEnter,CursorHold,InsertLeave" :<buffer> :lua "vim.lsp.codelens.refresh()")
       ; client autocmds
       ;  -- vim.api.nvim_command[[autocmd BufWritePre <buffer> lua vim.lsp.buf_request_sync(vim.api.nvim_get_current_buf(), 'workspace/executeCommand', {command = 'clean-ns', arguments = {vim.uri_from_bufnr(1), vim.api.nvim_win_get_cursor(0)[1], vim.api.nvim_win_get_cursor(0)[2]}, title = 'Clean Namespace'})]]

nvim/.config/nvim/fnl/dotfiles/plugin/orgbullets.fnl

@@ -1,3 +1,47 @@
 (module dotfiles.plugin.orgbullets
-  {autoload {org-bullets org-bullets}})
+        {autoload {nvim aniseed.nvim a aniseed.core ts-utils dotfiles.ts-utils}})
 
+(def stars ["◉" "⦾" "○" "✸" "✿" "✶" "•" "‣"])
+
+(def stars-query "(headline (stars) @stars)")
+
+(defn star-index [heading-level]
+      (let [star-count (a.count stars)
+            idx (math.fmod heading-level star-count)]
+        (if (< 0 idx)
+            idx
+            star-count)))
+
+(defonce extmark-namespace (vim.api.nvim_create_namespace :HeaderStars))
+
+(def star-captures (ts-utils.make-query :org stars-query))
+
+(defn gen-star-extmarks []
+      (when (= :org vim.bo.filetype)
+        (let [bufnr (vim.api.nvim_get_current_buf)
+              star-count (a.count stars)]
+          (vim.api.nvim_buf_clear_namespace bufnr extmark-namespace 0 -1)
+          (each [id node metadata (star-captures bufnr)]
+            (let [[start-line start-col end-row end-col] [(node:range)]
+                  heading-level (if (= start-line end-row)
+                                    (- end-col start-col))
+                  star (a.get stars (star-index heading-level))
+                  replacement (string.format (a.str "%" (+ 2 heading-level) :s)
+                                             star)]
+              (vim.api.nvim_buf_set_extmark bufnr extmark-namespace start-line
+                                            start-col
+                                            {:end_col end-col
+                                             :end_row end-row
+                                             :virt_text [[replacement []]]
+                                             :virt_text_pos :overlay
+                                             :hl_mode :combine}))))))
+
+(let [group (nvim.create_augroup :HeaderStars {:clear true})]
+  (nvim.create_autocmd [:FileChangedShellPost
+                        :Syntax
+                        :TextChanged
+                        :InsertLeave
+                        :WinScrolled]
+                       {: group
+                        ;; :pattern [:*.org]
+                        :callback gen-star-extmarks}))

nvim/.config/nvim/fnl/dotfiles/plugin/orgmode.fnl

@@ -1,8 +1,8 @@
-(module dotfiles.plugin.orgmode
+(module dotfiles.plugin.orgmode {autoload {orgmode orgmode}})
-  {autoload {orgmode orgmode}})
 
 (orgmode.setup_ts_grammar)
 
-(orgmode.setup
+(orgmode.setup {:org_agenda_files ["~/Dropbox/org/*" "~/my-orgs/**/*"]
-  {:org_agenda_files ["~/Dropbox/org/*" "~/my-orgs/**/*"]
+                :org_default_notes_file "~/Dropbox/org/refile.org"})
-   :org_default_notes_file "~/Dropbox/org/refile.org" })
+
+(require :dotfiles.plugin.orgbullets)

nvim/.config/nvim/fnl/dotfiles/plugin/paredit.fnl

@@ -1,76 +1,61 @@
 (module dotfiles.plugin.paredit
-  {autoload {nvim aniseed.nvim
+        {autoload {nvim aniseed.nvim
-             a aniseed.core
+                   a aniseed.core
-             nu aniseed.nvim.util
+                   nu aniseed.nvim.util
-             paredit paredit
+                   paredit paredit
-             ts-parsers nvim-treesitter.parsers
+                   ts-parsers nvim-treesitter.parsers
-             ts-utils nvim-treesitter.ts_utils
+                   ts-utils nvim-treesitter.ts_utils
-             languagetree vim.treesitter.languagetree
+                   languagetree vim.treesitter.languagetree}})
-             }})
 
-(defn list-member? [xs x]
+(defn list-member? [xs x] (a.some #(= x $1) (a.vals xs)))
-  (a.some #(= x $1) (a.vals xs)))
 
-(defn bool->int [bool]
+(defn bool->int [bool] (if bool 1 0))
-  (if bool 1 0))
 
-(defn language-at-cursor []
+(defn language-at-cursor [] (let [parser (ts-parsers.get_parser)
-  (let [parser (ts-parsers.get_parser)
+                                  current-node (ts-utils.get_node_at_cursor)
-        current-node (ts-utils.get_node_at_cursor)
+                                  range (if current-node [(current-node:range)])
-        range (if current-node
+                                  lang (if range
-                [(current-node:range)])
+                                           (languagetree.language_for_range parser
-        lang (if range
+                                                                            range))]
-               (languagetree.language_for_range parser range))]
+                              (if lang
-    (if lang
+                                  (lang:lang))))
-      (lang:lang))))
 
-(defn parser-language []
+(defn parser-language [] (let [parser (ts-parsers.get_parser)]
-  (let [parser (ts-parsers.get_parser)]
+                           (when parser
-    (when parser
+                             (parser:lang))))
-      (parser:lang))))
 
-(def- paredit-langs
+(def- paredit-langs [:clojure
-  [
+                     :fennel
-   :clojure
+                     :hy
-   :fennel
+                     :janet
-   :hy
+                     :julia
-   :janet
+                     :lfe
-   :julia
+                     :lisp
-   :lfe
+                     :racket
-   :lisp
+                     :scheme
-   :racket
+                     :shen])
-   :scheme
-   :shen
-   ])
 
-(def- paredit-host-langs
+(def- paredit-host-langs [:org :markdown :asciidoc])
-  [
-   :org
-   :markdown
-   :asciidoc
-   ])
 
-(defn- host-lang-in? [langs]
+(defn- host-lang-in? [langs] (list-member? langs (parser-language)))
-  (list-member? langs (parser-language)))
 
-(defn paredit-lang? [lang]
+(defn paredit-lang? [lang] (list-member? paredit-langs lang))
-  (list-member? paredit-langs lang))
 
 (defn TreeSitterLangParedit []
-  (when (host-lang-in? paredit-host-langs)
+      (when (host-lang-in? paredit-host-langs)
-    (when-let [cursor-lang (language-at-cursor)]
+        (when-let [cursor-lang (language-at-cursor)]
-      (->> cursor-lang
+                  (->> cursor-lang
-           (paredit-lang?)
+                       (paredit-lang?)
-           (bool->int)
+                       (bool->int)
-           (set nvim.g.paredit_mode))
+                       (set nvim.g.paredit_mode))
-      (nvim.fn.PareditInitBuffer))))
+                  (nvim.fn.PareditInitBuffer))))
 
 ; (nvim.del_augroup_by_name "BabeliteParedit")
 ; (nvim.get_autocmds {:group "BabeliteParedit"})
 
-(let [group (nvim.create_augroup "BabeliteParedit" {:clear true})]
+; (let [group (nvim.create_augroup "BabeliteParedit" {:clear true})]
-  (nvim.create_autocmd ["CursorHold" "CursorMoved"]
+;   (nvim.create_autocmd ["CursorHold" "CursorMoved"]
-                       {:group group
+;                        {:group group
-                        ;:pattern ["*.org" "*.md"]
+;                         ;:pattern ["*.org" "*.md"]
-                        :callback TreeSitterLangParedit}))
+;                         :callback TreeSitterLangParedit}))
-
+; 

nvim/.config/nvim/fnl/dotfiles/plugins.fnl

@@ -22,7 +22,6 @@
                 :Olical/conjure {:mod :conjure}
                 :Olical/fennel.vim {}
                 :airblade/vim-gitgutter {}
-                :akinsho/org-bullets.nvim {:mod :orgbullets}
                 :clojure-vim/vim-jack-in {}
                 :dhruvasagar/vim-table-mode {}
                 :folke/lsp-colors.nvim {}

nvim/.config/nvim/fnl/dotfiles/ts-utils.fnl

@@ -0,0 +1,12 @@
+(module dotfiles.ts-utils {autoload {nvim aniseed.nvim a aniseed.core}})
+
+(defn root [bufnr lang] (let [parser (vim.treesitter.get_parser bufnr lang {})
+                              tree (a.first (: parser :parse))]
+                          (: tree :root)))
+
+(defn make-query [lang query-string]
+      (let [query (vim.treesitter.parse_query lang "(headline (stars) @stars)")]
+        (fn [bufnr]
+          (let [root-node (root bufnr lang)
+                iter-captures (query.iter_captures query root-node bufnr 0 -1)]
+            iter-captures))))