commit cb69c5bc98114ccb0433d693fa22fc705d090b54 · hauleth.dev/dotfiles

+65 -8

modules/nvim.nix

···

       18
       18
        
               require('basic')

     

       19
       19
        
               EOF

     

       20
       20
        
             '';

     

       21
       21
       -
             packages.vimPackages = with pkgs.vimPlugins; {

     

       21
       21
       +
             packages.vimPackages = let

     

       22
       22
       +
               plugins = pkgs.vimPlugins;

     

       23
       23
       +
               ts = plugins.nvim-treesitter.withPlugins (

     

       24
       24
       +
                 g: [

     

       25
       25
       +
                   g.bibtex

     

       26
       26
       +
                   g.comment

     

       27
       27
       +
                   g.cpp

     

       28
       28
       +
                   g.css

     

       29
       29
       +
                   g.csv

     

       30
       30
       +
                   g.dhall

     

       31
       31
       +
                   g.diff

     

       32
       32
       +
                   g.djot

     

       33
       33
       +
                   g.dot

     

       34
       34
       +
                   g.editorconfig

     

       35
       35
       +
                   g.eex

     

       36
       36
       +
                   g.elixir

     

       37
       37
       +
                   g.erlang

     

       38
       38
       +
                   g.fennel

     

       39
       39
       +
                   g.fish

     

       40
       40
       +
                   g.git_config

     

       41
       41
       +
                   g.git_rebase

     

       42
       42
       +
                   g.gitattributes

     

       43
       43
       +
                   g.gitcommit

     

       44
       44
       +
                   g.glsl

     

       45
       45
       +
                   g.graphql

     

       46
       46
       +
                   g.haskell

     

       47
       47
       +
                   g.haskell_persistent

     

       48
       48
       +
                   g.hcl

     

       49
       49
       +
                   g.heex

     

       50
       50
       +
                   g.html

     

       51
       51
       +
                   g.javascript

     

       52
       52
       +
                   g.jq

     

       53
       53
       +
                   g.json

     

       54
       54
       +
                   g.julia

     

       55
       55
       +
                   g.just

     

       56
       56
       +
                   g.make

     

       57
       57
       +
                   g.mermaid

     

       58
       58
       +
                   g.nickel

     

       59
       59
       +
                   g.nix

     

       60
       60
       +
                   g.po

     

       61
       61
       +
                   g.printf

     

       62
       62
       +
                   g.prolog

     

       63
       63
       +
                   g.racket

     

       64
       64
       +
                   g.regex

     

       65
       65
       +
                   g.robots

     

       66
       66
       +
                   g.ruby

     

       67
       67
       +
                   g.rust

     

       68
       68
       +
                   g.scheme

     

       69
       69
       +
                   g.sql

     

       70
       70
       +
                   g.ssh_config

     

       71
       71
       +
                   g.terraform

     

       72
       72
       +
                   g.toml

     

       73
       73
       +
                   g.typescript

     

       74
       74
       +
                   g.typst

     

       75
       75
       +
                   g.yaml

     

       76
       76
       +
                   g.zig

     

       77
       77
       +
                 ]

     

       78
       78
       +
               );

     

       79
       79
       +
             in {

     

       22
       80
        
               start = [

     

       23
       23
       -
                 packer-nvim

     

       24
       24
       -
                 nvim-treesitter.withAllGrammars

     

       25
       25
       -
                 vim-nickel

     

       26
       26
       -
                 # XXX: Currently broken

     

       27
       27
       -
                 lua-utils-nvim

     

       28
       28
       -
                 neorg

     

       29
       29
       -
                 neorg-telescope

     

       81
       81
       +
                 plugins.packer-nvim

     

       82
       82
       +
                 plugins.vim-nickel

     

       83
       83
       +
                 plugins.lua-utils-nvim

     

       84
       84
       +
                 plugins.neorg

     

       85
       85
       +
                 plugins.neorg-telescope

     

       86
       86
       +
                 ts

     

       30
       87
        
               ];

     

       31
       88
        
       

     

       32
       89
        
               opt = [];

+4 -2

vim/.config/nvim/fnl/nvim/macro-init.fnl

···

       16
       16
        
       

     

       17
       17
        
       (fn augroup [name ...]

     

       18
       18
        
         "Define auto group"

     

       19
       19
       +
         (let [ast

     

       19
       20
        
         `(let [,(sym :au-id) (vim.api.nvim_create_augroup ,(view name) {:clear true})]

     

       20
       21
        
            (import-macros {: on} :nvim)

     

       21
       21
       -
            ,...

     

       22
       22
       -
            au-id))

     

       22
       22
       +
            (do ,...)

     

       23
       23
       +
            au-id)]

     

       24
       24
       +
         ast))

     

       23
       25
        
       

     

       24
       26
        
       ; TODO: Make argument passing more explicit and find another way to pass

     

       25
       27
        
       ; options. Example idea may be to parse argument list and translate them to the

+4 -4

vim/.config/nvim/fnl/relude/macro-init.fnl

···

       1
       1
        
       (fn use [mod names]

     

       2
       2
        
         (assert-compile (sym? mod) "expected symbol" mod)

     

       3
       3
        
         (let [mod-name (view mod)

     

       4
       4
       -
               splitted (vim.split mod-name "." {:plain true})

     

       5
       5
       -
               last (. splitted (length splitted))

     

       4
       4
       +
               split (vim.split mod-name "." {:plain true})

     

       5
       5
       +
               last (. split (length split))

     

       6
       6
        
               matcher (if (= names nil) (sym last) names)]

     

       7
       7
        
           `(local ,matcher (require ,mod-name))))

     

       8
       8
        
       

     

       9
       9
        
       (fn reuse [mod names]

     

       10
       10
        
         (assert-compile (sym? mod) "expected symbol" mod)

     

       11
       11
        
         (let [mod-name (view mod)

     

       12
       12
       -
               splitted (vim.split mod-name "." {:plain true})

     

       13
       13
       -
               last (. splitted (length splitted))

     

       12
       12
       +
               split (vim.split mod-name "." {:plain true})

     

       13
       13
       +
               last (. split (length split))

     

       14
       14
        
               matcher (if (= names nil) (sym last) names)]

     

       15
       15
        
           `(local ,matcher

     

       16
       16
        
                   (do

+11 -6

vim/.config/nvim/init.fnl

···

       71
       71
        
       

     

       72
       72
        
       (do

     

       73
       73
        
         ; Keep cursor in the middle

     

       74
       74
       -
         (let [value 9999]

     

       75
       75
       -
           (set opt.scrolloff value)

     

       76
       76
       -
           (augroup terminal-scrolloff

     

       77
       77
       -
                    (on BufEnter "term://*"

     

       74
       74
       +
         (let [value 9999

     

       75
       75
       +
               enter (fn []

     

       76
       76
       +
                         (cmd.echo "'hello'")

     

       78
       77
        
                        (set opt.window.signcolumn :no)

     

       79
       78
        
                        (set opt.window.scrolloff 0))

     

       80
       80
       -
                    (on BufLeave "term://*"

     

       79
       79
       +
               leave (fn []

     

       80
       80
       +
                       (cmd.echo "'bye'")

     

       81
       81
        
                        (set opt.window.signcolumn "yes:1")

     

       82
       82
       -
                        (set opt.window.scrolloff value)))))

     

       82
       82
       +
                        (set opt.window.scrolloff value))]

     

       83
       83
       +
           (set opt.scrolloff value)

     

       84
       84
       +
           (augroup terminal-scrolloff

     

       85
       85
       +
                    (on TermOpen "*" (enter))

     

       86
       86
       +
                    (on BufEnter "term://*" (enter))

     

       87
       87
       +
                    (on BufLeave "term://*" (leave)))))

     

       83
       88
        
       

     

       84
       89
        
       (do ; XXI century - we have cursors now

     

       85
       90
        
         (set opt.mouse :a))