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
|
;;; init-completion.el --- Completion Configuration File -*- lexical-binding: t -*-
;;; Commentary:
;; Config for completion-at-point (corfu), as well as orderless (see also init-minibuffer.el)
;; Most of it is taken from the READMEs and wikis of those packages
;;; Code:
(use-feature dabbrev
:diminish
:custom
(dabbrev-case-distinction nil)
(dabbrev-case-fold-search t)
(dabbrev-case-replace nil))
(use-feature hippie-expand
:config
(setq hippie-expand-try-functions-list
'(;yas-hippie-try-expand
try-expand-dabbrev
try-expand-all-abbrevs
try-expand-dabbrev-all-buffers
try-expand-dabbrev-from-kill
try-complete-file-name-partially
try-complete-file-name
try-expand-list
try-expand-line
try-complete-lisp-symbol-partially
try-complete-lisp-symbol))
;; https://www.emacswiki.org/emacs/HippieExpand#h5o-9
(defadvice he-substitute-string (after he-paredit-fix)
"Remove extra paren when expanding line in paredit."
(if (and (or smartparens-mode paredit-mode) (equal (substring str -1) ")"))
(progn (backward-delete-char 1) (forward-char))))
:bind
("C-M-/" . hippie-expand))
(use-package fancy-dabbrev
:diminish
:config
(global-fancy-dabbrev-mode)
(defun fancy-dabbrev-popup-advice (_next)
(local-set-key (kbd "C-M-/") #'fancy-dabbrev-backward))
(defun fancy-dabbrev-popup-exit-advice ()
(local-unset-key (kbd "C-M-/")))
(advice-add #'fancy-dabbrev--expand-again :before #'fancy-dabbrev-popup-advice)
(advice-add #'fancy-dabbrev--on-exit :after #'fancy-dabbrev-popup-exit-advice)
:bind ("M-/" . fancy-dabbrev-expand))
(use-feature emacs
:config
(setq completion-cycle-threshold 3)
(setq tab-always-indent 'complete)
(setq read-buffer-completion-ignore-case t
read-file-name-completion-ignore-case t
completion-ignore-case t))
(use-package orderless
:defer 2
:bind
(:map minibuffer-local-map
("C-l" . orderless-toggle-literal-matching))
(:map corfu-map
("C-l" . orderless-toggle-literal-matching))
:custom
(orderless-component-separator 'orderless-escapable-split-on-space)
(completion-styles '(orderless partial-completion basic))
(completion-category-defaults nil)
(completion-category-overrides '((file (styles . (partial-completion orderless)))))
(orderless-matching-styles '(orderless-literal orderless-regexp orderless-strict-initialism))
(orderless-style-dispatchers '(+orderless-dispatch))
:config
;; Inspired by https://github.com/oantolin/orderless/blob/ac4aeb66f331f4c4a430d5556071e33177304c37/README.org#interactively-changing-the-configuration
(defun orderless-toggle-literal-matching ()
"Toggle matching components literally for the rest of the session."
(interactive)
(if orderless-style-dispatchers
(progn
(setq-local +saved-orderless-matching-styles orderless-matching-styles
+saved-orderless-style-dispatchers orderless-style-dispatchers)
(setq-local orderless-matching-styles '(orderless-literal)
orderless-style-dispatchers nil))
(setq-local orderless-matching-styles +saved-orderless-matching-styles
orderless-style-dispatchers +saved-orderless-style-dispatchers))
(when vertico--input
(setq vertico--input t)
(vertico--update))
(when corfu--input
(setq corfu--input t)
(corfu--update)))
(defun orderless-strict-initialism (component &optional leading)
"Match a component as a strict initialism.
This means the characters in COMPONENT must occur in the
candidate, in that order, at the beginning of words, with
no words in between. If LEADING is non-nil, anchor to the
first word."
(orderless--separated-by '(seq (zero-or-more word) (zero-or-more punct))
(cl-loop for char across component collect `(seq word-start ,char))
(when leading '(seq buffer-start))))
(defun orderless-strict-leading-initialism (component)
"Match a component as a strict leading initialism.
This means the characters in COMPONENT must occur in the
candidate, in that order, at the beginning of words, with
no words in between, beginning with the first word."
(orderless-strict-initialism component t))
;; based on https://github.com/minad/consult/wiki#minads-orderless-configuration
(defvar +orderless-dispatch-alist
'((?% . char-fold-to-regexp)
(?! . orderless-without-literal)
(?` . orderless-strict-leading-initialism)
(?= . orderless-literal)
(?_ . orderless-prefix)
(?~ . orderless-flex)))
(defun +orderless--suffix-regexp ()
(if (and (boundp 'consult--tofu-char) (boundp 'consult--tofu-range))
(format "[%c-%c]*$"
consult--tofu-char
(+ consult--tofu-char consult--tofu-range -1))
"$"))
;; Recognizes the following patterns:
;; * ~flex flex~
;; * =literal literal=
;; * _prefix prefix_
;; * %char-fold char-fold%
;; * `strict-leading-initialism strict-leading-initialism`
;; * !without-literal without-literal!
;; * .ext (file extension)
;; * regexp$ (regexp matching at end)
(defun +orderless-dispatch (word _index _total)
(cond
;; Ensure that $ works with Consult commands, which add disambiguation suffixes
((string-suffix-p "$" word)
`(orderless-regexp . ,(concat (substring word 0 -1) (+orderless--suffix-regexp))))
;; File extensions
((and (or minibuffer-completing-file-name
(derived-mode-p 'eshell-mode))
(string-match-p "\\`\\.." word))
`(orderless-regexp . ,(concat "\\." (substring word 1) (+orderless--suffix-regexp))))
;; Ignore single !
((equal "!" word) `(orderless-literal . ""))
;; Prefix and suffix
((if-let (x (assq (aref word 0) +orderless-dispatch-alist))
(cons (cdr x) (substring word 1))
(when-let (x (assq (aref word (1- (length word))) +orderless-dispatch-alist))
(cons (cdr x) (substring word 0 -1))))))))
;; code completion - corfu
(use-package corfu
:ensure (corfu :files (:defaults "extensions/*"))
:custom
(corfu-cycle t)
:bind (:map corfu-map
("TAB" . corfu-next)
([tab] . corfu-next)
("S-TAB" . corfu-previous)
([backtab] . corfu-previous))
:hook (elpaca-after-init . global-corfu-mode))
(use-extension corfu corfu-indexed
:config (corfu-indexed-mode 1))
(use-extension corfu corfu-quick
:bind (:map corfu-map
("M-;" . corfu-quick-insert)
("M-'" . corfu-quick-exit)))
(use-extension corfu corfu-history
:after savehist
:config
(corfu-history-mode 1)
(add-to-list 'savehist-additional-variables 'corfu-history))
(use-extension corfu corfu-popupinfo
:hook (global-corfu-mode . corfu-popupinfo-mode))
(use-package cape
:bind (("C-c p p" . completion-at-point) ;; capf
("C-c p t" . complete-tag) ;; etags
("C-c p d" . cape-dabbrev) ;; or dabbrev-completion
("C-c p h" . cape-history)
("C-c p f" . cape-file)
("C-c p k" . cape-keyword)
("C-c p s" . cape-elisp-symbol)
("C-c p e" . cape-elisp-block)
("C-c p a" . cape-abbrev)
("C-c p l" . cape-line)
("C-c p w" . cape-dict)
("C-c p :" . cape-emoji)
("C-c p \\" . cape-tex)
("C-c p _" . cape-tex)
("C-c p ^" . cape-tex)
("C-c p &" . cape-sgml)
("C-c p r" . cape-rfc1345))
:custom
(cape-dict-file "/usr/share/dict/words")
:init
(add-to-list 'completion-at-point-functions #'cape-file t)
(add-to-list 'completion-at-point-functions #'cape-dabbrev t)
(add-to-list 'completion-at-point-functions #'cape-dict t))
(provide 'init-completion)
;;; init-completion.el ends here
|