-
Notifications
You must be signed in to change notification settings - Fork 0
/
lightning-keymap-mode-functions.el
248 lines (225 loc) · 9.36 KB
/
lightning-keymap-mode-functions.el
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
;;; lightning-keymap-mode-functions.el
;; Contains additional functions used within the lightning-keymap-mode.
;; Author: Philipp Müller <[email protected]>
;; Maintainer: Philipp Müller <[email protected]>
;; URL: https://gitlab.com/theGreatWhiteShark/lightning-keymap-mode
;; This program is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;; Commentary:
;;
;; Functions defined within this file
;;
;; `lightning-keymap-mode-replace-string'
;;
;; Interactive function to replace strings using default values.
;;
;; Basically this function is just a wrapper around the
;; `replace-string' function. But instead of saving the `FROM' and
;; `TO' arguments of the last replacement and performing the exact
;; same operation on default, this function provides default
;; values for the `FROM' argument.
;; This default value will be the word at point, which is
;; extracted using the `thing-at-point' function using the
;; arguments `word' and `no-properties'.
;; The `replacement-context' variable is a string, which is meant
;; to region the function is replacing strings in (if none was
;; marked). There are three valid options: 'line', 'paragraph',
;; and 'buffer'.
;; In order to use this function in the `lightning-keymap-mode'
;; bound to '\' key, be sure to set the
;; `lightning-keymap-mode-modifies-string-replacement' variable to
;; non-nil.
;;
;; `lightning-keymap-mode-trim'
;;
;; Trims whitespaces, newlines, and tabs in a certain direction.
;;
;; This function deletes all newlines, tabulators, and whitespaces
;; in a certain direction and introduces a single whitespace
;; instead. Whenever there is neither a whitespace, newline, or
;; tabulator the function does alter the buffer.
;;
;; The `direction' argument is a numeric value. If it is smaller
;; then `0' all whitespaces, newlines, and tabulators to the left
;; of the `point' are trimmed. If bigger then `0' they are trimmed
;; to the right. For a `direction' equals zero the whitespaces,
;; newlines, and tabulators are trimmed in both directions."
;;
;;
;; For more information check out the projects GitLab page:
;; https://gitlab.com/theGreatWhiteShark/lightning-keymap-mode
(defun lightning-keymap-mode-replace-string (replacement-context)
"Interactive function to replace strings using default values
Basically this function is just a wrapper around the `replace-string'
function. But instead of saving the `FROM' and `TO' arguments of the
last replacement and performing the exact same operation on default,
this function provides default values for the `FROM' argument.
This default value will be the word at point, which is extracted using
the `thing-at-point' function using the arguments `word' and
`no-properties'.
The `replacement-context' variable is a string, which is meant to
region the function is replacing strings in (if none was
marked). There are three valid options: 'line', 'paragraph', and
'buffer'.
In order to use this function in the `lightning-keymap-mode' bound to
'\' key, be sure to set the
`lightning-keymap-mode-modifies-string-replacement' variable to
non-nil."
(interactive)
;; Sanity check for the format of the input argument
(unless (stringp replacement-context)
(inline-error "The input argument `replacement-context' for
the `lightning-keymap-mode-replace-string' function has to be
a string!"))
(unless (or (string= replacement-context "line")
(string= replacement-context "paragraph")
(string= replacement-context "buffer"))
(inline-error "The input argument`replacement-context' for the
`lightning-keymap-mode-replace-string' function has to be either
'line', 'paragraph', or 'buffer'!"))
;; Get the default string (either the word at point of a
;; marked region of the buffer
(setq lightning-keymap-replace-from-default
(thing-at-point 'word 'no-properties))
;; Query the user what string to replace. If the user
;; just types [return], the default value will be used
;; instead.
;; Unset the query defaults, since I won't use them anyway
(setq query-replace-defaults nil)
;; Use a different text for prompting depending on whether a
;; region was marked or not
(if mark-active
(setq lightning-keymap-replace-from
(query-replace-read-from
(concat "Replace string in region (default: "
lightning-keymap-replace-from-default
")") ""))
(setq lightning-keymap-replace-from
(query-replace-read-from
(concat "Replace string in "
replacement-context
" (default: "
lightning-keymap-replace-from-default
")") "")))
;; Check, whether the user wants to use the default
;; value instead.
(when (string= lightning-keymap-replace-from "")
(setq lightning-keymap-replace-from
lightning-keymap-replace-from-default))
;; Query for the replace-to argument
(if mark-active
(setq lightning-keymap-replace-to
(query-replace-read-to
""
(concat "Replace string in region '"
lightning-keymap-replace-from "'")
""))
(setq lightning-keymap-replace-to
(query-replace-read-to
""
(concat "Replace string in paragraph "
replacement-context " '"
lightning-keymap-replace-from "'")
"")))
;; Perform the replacement in either a marked region or the
;; current paragraph
(if mark-active
(replace-string lightning-keymap-replace-from
lightning-keymap-replace-to
nil (region-beginning) (region-end))
(save-excursion
;; Depending on the value of the `replacement-context' variable,
;; the FROM string is either replaced in the current line, the
;; current paragraph, or the whole buffer.
(if (string= replacement-context "line")
(progn
;; Replacement in the current line
(set-mark (line-end-position))
(move-beginning-of-line 1)
(replace-string lightning-keymap-replace-from
lightning-keymap-replace-to
nil (region-beginning) (region-end)))
(if (string= replacement-context "paragraph")
(progn
;; Replacement in the current paragraph
(backward-paragraph)
(set-mark (point))
(forward-paragraph)
(replace-string lightning-keymap-replace-from
lightning-keymap-replace-to
nil (region-beginning) (region-end)))
(progn
;; Replacement in the whole buffer
(replace-string lightning-keymap-replace-from
lightning-keymap-replace-to
nil (buffer-end -1) (buffer-end 1)))
))))
)
(defun lightning-keymap-mode-trim (direction)
"Trims whitespaces, newlines, and tabs in a certain direction.
This function deletes all newlines, tabulators, and whitespaces in a
certain direction and introduces a single whitespace instead. Whenever
there is neither a whitespace, newline, or tabulator the function does
alter the buffer.
The `direction' argument is a numeric value. If it is smaller then `0'
all whitespaces, newlines, and tabulators to the left of the `point'
are trimmed. If bigger then `0' they are trimmed to the right. For a
`direction' equals zero the whitespaces, newlines, and tabulators are
trimmed in both directions."
(interactive)
;; Check, whether the argument is numeric
(unless (numberp direction)
(inline-error "The `direction' argument of the
`lightning-keymap-mode-trim' function has to be provided as a
numerical value. < 0 - trimmed to the left, > 0 - trimmed to the
right, == 0 - trimmed in both directions"))
;; Regular expression containing the elements we want to trim:
;; whitespaces, tabulators, and newlines
(setq lightning-keymap-mode-trim-regexp "[^\n\t\r[:blank:]]")
;; Delete to the left
(if (<= direction 0)
(progn
(save-excursion
(setq trim-region-end (point))
;; Leaves the point at the first symbol, which does not
;; matches the regular expression
(re-search-backward lightning-keymap-mode-trim-regexp)
;; One step to the right, since we do not want to delete the
;; symbol found in the search.
(right-char)
(setq trim-region-start (point)))
;;
;; If there is a region to trim, do it.
(if (< trim-region-start trim-region-end)
(progn
(kill-region trim-region-start trim-region-end)
(insert " ")))))
;; Delete to the right
(if (>= direction 0)
(save-excursion
(setq trim-region-start (point))
;; Leaves the point after the first symbol, which does not
;; matches the regular expression
(re-search-forward lightning-keymap-mode-trim-regexp)
;; One step to the left, since we do not want to delete the
;; symbol found in the search.
(left-char)
(setq trim-region-end (point))
;;
;; If there is a region to trim, do it.
(if (< trim-region-start trim-region-end)
(progn
(kill-region trim-region-start trim-region-end)
(insert " ")))))
)
(provide 'lightning-keymap-mode-functions)
;;
;;; End of lightning-keymap-mode-functions.el