summaryrefslogtreecommitdiff
path: root/zlglib.vim
blob: 0e280ff051f04194362274f14f0336b5ba1bf776 (plain)
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
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
" Name: zlglib.vim
" Author: zlg <zlg+vim@zlg.space>
" License: Vim
"
" Integrate by symlinking to this file inside the 'autoload' directory:
"     cd $HOME/.vim/autoload
"     ln -s /path/to/zlglib.vim zlg.vim
"
" Next, hook things up as you wish via something like :call zlg#foo()

" StripTrailingWhitespaces, by Drew Neil of vimcasts.org {{{1
function! zlg#StripTrailingWhitespaces()
	" Save last search and cursor position
	let _s=@/
	let l = line(".")
	let c = col(".")
	" Do the business:
	%s/\s\+$//e
	" Restore previous search history and cursor position
	let @/=_s
	call cursor(l, c)
endfunction

" SynStack, by Drew Neil of vimcasts.org {{{1
function! zlg#SynStack()
	if !exists("*synstack")
		return
	endif
	echo map(synstack(line('.'), col('.')), 'synIDattr(v:val, "name")')
endfunction

" CountCodeLines, by zlg {{{1
function! zlg#CountCodeLines()
	let code_count = 0
	for line in getbufline("%", 1, "$")
		if (len(line) > 0 && match(line, '\S\+') > -1)
			if (s:IsCommentLine(line) == 1)
				continue
			endif
			let code_count += 1
		endif
	endfor
	echo code_count . ' lines of code.'
endfunction

" IsCommentLine, by zlg {{{1
" Meant to be used with CountCodeLines()
function! s:IsCommentLine(line)
	let l:comtypes = []
	let l:comlist = split(&comments, ',')
	for i in comlist
		let l:type = split(i, ':')
		if len(type) > 1
			let l:opt = type[1]
		else
			let l:opt = type[0]
		endif
		call add(comtypes, opt)
	endfor
	let i = 0
	while i < len(comtypes)
		if match(a:line, '^\s*' . escape(comtypes[i], '/*')) > -1
			return 1
		endif
		let i += 1
	endwhile
	return 0
endfunction

" InsertDOW, by zlg {{{1
function! zlg#InsertDOW()
	" Let's backup a random register
	let tmpx = @x
	let @x = system("date +\"%a \" -d" . strftime("%Y") . "-" . substitute(expand("<cWORD>"), ":", "", ""))
	normal "xP
	" Join, since it apparently is on a line instead of just a string
	j 1
	" Return the value in the x register
	let @x = tmpx
endfunction

" BufDiff, by zlg {{{1
" Function: BufDiff
" Author: zlg <zlg+viml@zlg.space>
" Date: 2018-10-12
" License: GNU GPL, version 3 <https://gnu.org/licenses/gpl-3.0.html>
" Description: Open a new tab page with two or three buffers and enter diff mode.
" Long Description:
" BufDiff accepts two or three buffer arguments and opens a new tab page to
" work with them in diff mode. This ensures that your existing window and
" buffer layout is preserved while providing an easy way to enter a diff
" session. The arguments can be any argument that can also be passed to
" the ":buffer" Ex-command, including partial filenames (if quoted).
function! BufDiff(buf1, buf2, ...)
	let fname = substitute(expand("<sfile>"), "^function ", "", "")
	if a:0 > 1
		echohl ErrorMsg
		echomsg l:fname . ": This function accepts a maximum of three arguments."
		echohl None
		return
	endif

	" Check for a third buffer, which will default to zero if not present
	let a:buf3 = get(a:, 1, 0)

	if !bufexists(a:buf1) || !bufexists(a:buf2) || (a:0 == 1 && !bufexists(a:buf3))
		echohl ErrorMsg
		echomsg l:fname . ": One or more buffer number(s) not found!"
		echohl None
		return
	else
		tabnew
		exe ":buffer " . a:buf1
		diffthis
		vsplit
		exe ":buffer " . a:buf2
		diffthis
		if a:buf3
			vsplit
			exe ":buffer " . a:buf3
			diffthis
		endif
		return
	endif
endfunction

" SwapKeys, by zlg {{{1
" This function isn't that fancy; it just flips a variable and calls the
" mapping function.
function! zlg#SwapKeys()
	if (exists("g:use_dvorak") && (g:use_dvorak == 1 || g:use_dvorak == 0))
		let g:use_dvorak = (!g:use_dvorak)
		call SetKeyMap()
	else
		echohl ErrorMsg
		echomsg "g:use_dvorak is either unset, or an invalid value. Set to 0 or 1.
		echohl None
		return
	endif
endfunction

" SetKeyMap, by zlg {{{1
" Function: SetKeyMap
" Author: zlg <zlg+vim@zlg.space>
" Date: 2018-11-15
" License: GNU GPL, version 3 <https://gnu.org/licenses/gpl-3.0.html>
" Long Description:
" SetKeyMap allows the user to set their keybindings according to the value of
" a global variable. In this case, it's g:use_dvorak, to swap between Dvorak
" and QWERTY layouts. It can be extended to use any number of key mappings
" that you need.
function! zlg#SetKeyMap()
	if g:use_dvorak == 1
		" I use a Dvorak keyboard, so standard vim movement keys are a hassle.
		" Since mnemonics are helpful all around, I need a mapping that gives me
		" pain-free file navigation without screwing up mnemonics (too much).
		"
		" Thus:
		" (D)elete is now (K)ill: d2w == k2w "kill 2 words"
		" Un(T)il is now (J)ump-To: dt( == kj( "kill, jump-to paren"
		" (N)ext is now (L)eap: cn == cl "change up to leap point"

		" Standard movement, which is the true focus of this hack.
		" Mnemonics are awesome, so let's preserve as much as possible.
		noremap d h
		noremap h j
		noremap t k
		noremap n l
		noremap D H
		noremap H J
		noremap T K
		noremap N L

		noremap gh gj
		noremap gt gk

		" I work with tabs every now and then. No, I don't have a mnemonic.
		noremap gj gt
		noremap gJ gT

		" Window movement, equally important
		noremap <C-w>d <C-w>h
		noremap <C-w>h <C-w>j
		noremap <C-w>t <C-w>k
		noremap <C-w>n <C-w>l

		nnoremap <C-w><C-d> <C-w><C-h>
		nnoremap <C-w><C-h> <C-w><C-j>
		nnoremap <C-w><C-t> <C-w><C-k>
		nnoremap <C-w><C-n> <C-w><C-l>

		nnoremap <C-d> <C-w>h
		nnoremap <C-h> <C-w>j
		nnoremap <C-t> <C-w>k
		nnoremap <C-n> <C-w>l

		" Account for tag jumping
		nnoremap <C-j> <C-t>

		" Remappings for the D key
		noremap k d
		noremap K D

		" Remappings for the T key
		noremap j t
		noremap J T

		" Remapping for the L key
		noremap l n
		noremap L N

		" General purpose help; the originals remain for convenience
		noremap - 0
		noremap _ $

		" Fold-related keybindings
		noremap zh zj
		noremap zt zk

		echomsg "Bindings set to Dvorak"
	else
		" set qwerty keys; basically just resetting things
		noremap h h
		noremap j j
		noremap k k
		noremap l l
		noremap H H
		noremap J J
		noremap K K
		noremap L L

		noremap gj gj
		noremap gh gh

		noremap gt gt
		noremap gT gT

		noremap <C-w>h <C-w>h
		noremap <C-w>j <C-w>j
		noremap <C-w>h <C-w>k
		noremap <C-w>l <C-w>l

		nnoremap <C-w><C-h> <C-w><C-h>
		nnoremap <C-w><C-j> <C-w><C-j>
		nnoremap <C-w><C-k> <C-w><C-k>
		nnoremap <C-w><C-l> <C-w><C-l>

		nnoremap <C-h> <C-w>h
		nnoremap <C-j> <C-w>j
		nnoremap <C-k> <C-w>k
		nnoremap <C-l> <C-w>l

		nnoremap <C-t> <C-t>

		noremap d d
		noremap D D

		noremap t t
		noremap T T

		noremap n n
		noremap N N

		noremap - 0
		noremap _ $

		noremap zj zj
		noremap zk zk
		echomsg "Bindings set to QWERTY"
	endif
endfunction

" Custom folding display function
function! MyFoldText()
	let indent = repeat('	', indent(v:foldstart))
	let line = substitute(getline(v:foldstart), '\v^\s+', '', '')
	let folded_lines = v:foldend - v:foldstart
	return indent . line . ' (' . folded_lines . 'L)'
endfunction

" vim: foldmethod=marker