fnl/plugins/treesitter.fnl


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

;; Treesitter parser installation and built-in feature configuration.

(import-macros {: autocmd : keymaps} :macros)

(local parsers [:bash
                :c
                :comment
                :dockerfile
                :elixir
                :erlang
                :fennel
                :graphql
                :haskell
                :hcl
                :html
                :http
                :json
                :latex
                :lua
                :make
                :markdown
                :markdown_inline
                :ocaml
                :ocaml_interface
                :python
                :rust
                :sql
                :toml
                :unison
                :vim
                :vimdoc
                :xml
                :yaml])

(λ setup-textobjects []
  (let [textobjects (require :nvim-treesitter-textobjects)
        select (require :nvim-treesitter-textobjects.select)
        swap (require :nvim-treesitter-textobjects.swap)
        move (require :nvim-treesitter-textobjects.move)]
    (textobjects.setup {:select {:lookahead true
                                 :selection_modes {"@parameter.outer" :v
                                                   "@function.outer" :V
                                                   "@class.outer" :<c-v>}
                                 :include_surrounding_whitespace true}
                        :move {:set_jumps true}})
    (keymaps [[:x :o]
              :aa
              (λ []
                (select.select_textobject "@parameter.outer" :textobjects))
              {}] [[:x :o]
                                :ia
                                (λ []
                                  (select.select_textobject "@parameter.inner"
                                                            :textobjects))
                                {}]
             [[:x :o]
              :af
              (λ []
                (select.select_textobject "@function.outer" :textobjects))
              {}] [[:x :o]
                               :if
                               (λ []
                                 (select.select_textobject "@function.inner"
                                                           :textobjects))
                               {}]
             [[:x :o]
              :ii
              (λ []
                (select.select_textobject "@conditional.outer" :textobjects))
              {}] [[:x :o]
                               :ai
                               (λ []
                                 (select.select_textobject "@conditional.inner"
                                                           :textobjects))
                               {}]
             [[:x :o]
              :il
              (λ []
                (select.select_textobject "@loop.outer" :textobjects))
              {}] [[:x :o]
                               :al
                               (λ []
                                 (select.select_textobject "@loop.inner"
                                                           :textobjects))
                               {}]
             [[:x :o]
              :ac
              (λ []
                (select.select_textobject "@class.outer" :textobjects))
              {}] [[:x :o]
                               :at
                               (λ []
                                 (select.select_textobject "@comment.outer"
                                                           :textobjects))
                               {}]
             [[:x :o]
              :ic
              (λ []
                (select.select_textobject "@class.inner" :textobjects))
              {}] [[:x :o]
                               :as
                               (λ []
                                 (select.select_textobject "@local.scope"
                                                           :locals))
                               {}] ;; Swap
             [:n
              :<leader>a
              (λ []
                (swap.swap_next "@parameter.inner"))
              {}] [:n
                               :<leader>A
                               (λ []
                                 (swap.swap_previous "@parameter.inner"))
                               {}] ;; Move
             [[:n :x :o]
              "]m"
              (λ []
                (move.goto_next_start "@function.outer" :textobjects))
              {}] [[:n :x :o]
                               "]]"
                               (λ []
                                 (move.goto_next_start "@class.outer"
                                                       :textobjects))
                               {}]
             [[:n :x :o]
              "]o"
              (λ []
                (move.goto_next_start ["@loop.inner" "@loop.outer"]
                                      :textobjects))
              {}] [[:n :x :o]
                               "]s"
                               (λ []
                                 (move.goto_next_start "@local.scope" :locals))
                               {}]
             [[:n :x :o]
              "]z"
              (λ []
                (move.goto_next_start "@fold" :folds))
              {}] [[:n :x :o]
                               "]M"
                               (λ []
                                 (move.goto_next_end "@function.outer"
                                                     :textobjects))
                               {}]
             [[:n :x :o]
              "]["
              (λ []
                (move.goto_next_end "@class.outer" :textobjects))
              {}] [[:n :x :o]
                               "[m"
                               (λ []
                                 (move.goto_previous_start "@function.outer"
                                                           :textobjects))
                               {}]
             [[:n :x :o]
              "[["
              (λ []
                (move.goto_previous_start "@class.outer" :textobjects))
              {}] [[:n :x :o]
                               "[M"
                               (λ []
                                 (move.goto_previous_end "@function.outer"
                                                         :textobjects))
                               {}]
             [[:n :x :o]
              "[]"
              (λ []
                (move.goto_previous_end "@class.outer" :textobjects))
              {}] [[:n :x :o]
                               "]i"
                               (λ []
                                 (move.goto_next "@conditional.outer"
                                                 :textobjects))
                               {}]
             [[:n :x :o]
              "[i"
              (λ []
                (move.goto_previous "@conditional.outer" :textobjects))
              {}])))

(λ config []
  (let [treesitter (require :nvim-treesitter)]
    (treesitter.install parsers))
  (autocmd :FileType
           {:callback (λ [args]
                        (pcall vim.treesitter.start args.buf)
                        (tset vim.bo args.buf :indentexpr
                              "v:lua.require'nvim-treesitter'.indentexpr()"))})
  (setup-textobjects))

{1 :nvim-treesitter/nvim-treesitter
 :branch :main
 :dependencies [{1 :nvim-treesitter/nvim-treesitter-textobjects :branch :main}]
 :build ":TSUpdate"
 :event [:VeryLazy]
 : config}