mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-18 8f6f2705a38e2515b6c57fda12c5be29fb9a798f
commit | author | age
5cb5f7 1 ;;; helm-mode.el --- Enable helm completion everywhere. -*- lexical-binding: t -*-
C 2
3 ;; Copyright (C) 2012 ~ 2018 Thierry Volpiatto <thierry.volpiatto@gmail.com>
4
5 ;; This program is free software; you can redistribute it and/or modify
6 ;; it under the terms of the GNU General Public License as published by
7 ;; the Free Software Foundation, either version 3 of the License, or
8 ;; (at your option) any later version.
9
10 ;; This program is distributed in the hope that it will be useful,
11 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 ;; GNU General Public License for more details.
14
15 ;; You should have received a copy of the GNU General Public License
16 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18 ;;; Code:
19
20 (require 'cl-lib)
21 (require 'helm)
22 (require 'helm-lib)
23 (require 'helm-files)
24
25 (defvar crm-separator)
26
27
28 (defgroup helm-mode nil
29   "Enable helm completion."
30   :group 'helm)
31
32 (defcustom helm-completing-read-handlers-alist
33   '((describe-function . helm-completing-read-symbols)
34     (describe-variable . helm-completing-read-symbols)
35     (describe-symbol . helm-completing-read-symbols)
36     (debug-on-entry . helm-completing-read-symbols)
37     (find-function . helm-completing-read-symbols)
38     (disassemble . helm-completing-read-symbols)
39     (trace-function . helm-completing-read-symbols)
40     (trace-function-foreground . helm-completing-read-symbols)
41     (trace-function-background . helm-completing-read-symbols)
42     (find-tag . helm-completing-read-default-find-tag)
43     (org-capture . helm-org-completing-read-tags)
44     (org-set-tags . helm-org-completing-read-tags)
45     (ffap-alternate-file . nil)
46     (tmm-menubar . nil)
47     (find-file . nil)
48     (find-file-at-point . helm-completing-read-sync-default-handler)
49     (ffap . helm-completing-read-sync-default-handler)
50     (execute-extended-command . nil)
51     (dired-do-rename . helm-read-file-name-handler-1)
52     (dired-do-copy . helm-read-file-name-handler-1)
53     (dired-do-symlink . helm-read-file-name-handler-1)
54     (dired-do-relsymlink . helm-read-file-name-handler-1)
55     (dired-do-hardlink . helm-read-file-name-handler-1)
56     (basic-save-buffer . helm-read-file-name-handler-1)
57     (write-file . helm-read-file-name-handler-1)
58     (write-region . helm-read-file-name-handler-1))
59   "Completing read functions for specific Emacs commands.
60
61 By default `helm-mode' use `helm-completing-read-default-handler' to
62 provide helm completion in each `completing-read' or `read-file-name'
63 found, but other functions can be specified here for specific
64 commands. This also allow disabling helm completion for some commands
65 when needed.
66  
67 Each entry is a cons cell like (EMACS_COMMAND . COMPLETING-READ_HANDLER)
68 where key and value are symbols.
69
70 Each key is an Emacs command that use originaly `completing-read'.
71
72 Each value maybe a helm function that takes same arguments as
73 `completing-read' plus NAME and BUFFER, where NAME is the name of the new
74 helm source and BUFFER the name of the buffer we will use, but it can
75 be also a function not using helm, in this case the function should
76 take same args as `completing-read' and not be prefixed by \"helm-\".
77
78 `helm' will use the name of the command calling `completing-read' as
79 NAME and BUFFER will be computed as well with NAME but prefixed with
80 \"*helm-mode-\".
81
82 This function prefix name must start by \"helm-\" when it uses helm,
83 otherwise `helm' assumes the function is not a helm function and
84 expects same args as `completing-read', this allow you to define a
85 handler not using helm completion.
86
87 Example:
88
89     (defun foo/test ()
90       (interactive)
91       (message \"%S\" (completing-read \"test: \" '(a b c d e))))
92
93     (defun helm-foo/test-completing-read-handler (prompt collection
94                                                   predicate require-match
95                                                   initial-input hist def
96                                                   inherit-input-method
97                                                   name buffer)
98       (helm-comp-read prompt collection :marked-candidates t
99                                         :name name
100                                         :buffer buffer))
101
102     (add-to-list 'helm-completing-read-handlers-alist
103                  '(foo/test . helm-foo/test-completing-read-handler))
104
105
106 We want here to make the regular `completing-read' in `foo/test'
107 returns a list of candidate(s) instead of a single candidate.
108  
109 Note that this function will be reused for ALL the `completing-read'
110 of this command, so it should handle all cases, e.g
111 If first `completing-read' complete against symbols and
112 second `completing-read' should handle only buffer,
113 your specialized function should handle the both.
114
115 If the value of an entry is nil completion will fall back to
116 emacs vanilla behavior.
117 Example:
118
119 If you want to disable helm completion for `describe-function', use:
120
121     (describe-function . nil)
122
123 Ido is also supported, you can use `ido-completing-read' and
124 `ido-read-file-name' as value of an entry or just 'ido.
125 Example:
126 Enable ido completion for `find-file':
127
128     (find-file . ido)
129
130 same as
131
132     (find-file . ido-read-file-name)
133
134 Note that you don't need to enable `ido-mode' for this to work, see
135 `helm-mode' documentation."
136   :group 'helm-mode
137   :type '(alist :key-type symbol :value-type symbol))
138
139 (defcustom helm-comp-read-case-fold-search helm-case-fold-search
140   "Default Local setting of `helm-case-fold-search' for `helm-comp-read'.
141 See `helm-case-fold-search' for more info."
142   :group 'helm-mode
143   :type 'symbol)
144
145 (defcustom helm-mode-handle-completion-in-region t
146   "Whether to replace or not `completion-in-region-function'.
147 This enable support for `completing-read-multiple' and `completion-at-point'
148 when non--nil."
149   :group 'helm-mode
150   :type 'boolean)
151
152 (defcustom helm-mode-reverse-history t
153   "Display history source after current source in `helm-mode' handled commands."
154   :group 'helm-mode
155   :type 'boolean)
156
157 (defcustom helm-mode-no-completion-in-region-in-modes nil
158   "A list of modes that do not want helm for `completion-in-region'."
159   :group 'helm-mode
160   :type 'boolean)
161
162 (defcustom helm-completion-in-region-fuzzy-match nil
163   "Whether `helm-completion-in-region' use fuzzy matching or not.
164 Affect among others `completion-at-point', `completing-read-multiple'."
165   :group 'helm-mode
166   :type 'boolean)
167
168 (defcustom helm-completion-in-region-default-sort-fn
169   'helm-completion-in-region-sort-fn
170   "The default sort function to sort candidates in completion-in-region.
171
172 When nil no sorting is done.
173 The function is a `filtered-candidate-transformer' function which takes
174 two args CANDIDATES and SOURCE.
175 It will be used only when `helm-completion-in-region-fuzzy-match' is
176 nil otherwise fuzzy use its own sort function."
177   :group 'helm-mode
178   :type 'function)
179
180 (defcustom helm-mode-fuzzy-match nil
181   "Enable fuzzy matching in `helm-mode' globally.
182 Note that this will slow down completion and modify sorting
183 which is unwanted in many places.
184 This affect only the functions with completing-read helmized by helm-mode.
185 To fuzzy match `completion-at-point' and friends see
186 `helm-completion-in-region-fuzzy-match'."
187   :group 'helm-mode
188   :type 'boolean)
189
190 (defcustom helm-mode-minibuffer-setup-hook-black-list '(minibuffer-completion-help)
191   "Incompatible `minibuffer-setup-hook' functions go here.
192 A list of symbols.
193 Helm-mode is rejecting all lambda's, byte-code fns
194 and all functions belonging in this list from `minibuffer-setup-hook'."
195   :group 'helm-mode
196   :type '(repeat (choice symbol)))
197
198 (defcustom helm-completing-read-dynamic-complete nil
199   "Use dynamic completion in `completing-read' when non-nil.
200
201 The default is to not use this because it is most of the time unneeded
202 in `completing-read' and thus it is much more slower.
203 If you feel one emacs function need this you have better time to tell
204 `helm-mode' to use a dynamic completion for this function only by using
205 `helm-completing-read-handlers-alist' with an entry like this:
206
207     (my-function . helm-completing-read-sync-default-handler)
208
209 So you should not change the default setting of this variable unless you
210 know what you are doing."
211   :group 'helm-mode
212   :type 'boolean)
213
214
215 (defvar helm-comp-read-map
216   (let ((map (make-sparse-keymap)))
217     (set-keymap-parent map helm-map)
218     (define-key map (kbd "<C-return>") 'helm-cr-empty-string)
219     (define-key map (kbd "M-RET")      'helm-cr-empty-string)
220     map)
221   "Keymap for `helm-comp-read'.")
222
223 ;;; helm-comp-read
224 ;;
225 ;;
226 (defun helm-cr-empty-string ()
227   "Return empty string."
228   (interactive)
229   (with-helm-alive-p
230     (helm-exit-and-execute-action
231      (lambda (_candidate)
232          (identity "")))))
233 (put 'helm-cr-empty-string 'helm-only t)
234
235 (defun helm-mode--keyboard-quit ()
236   ;; Use this instead of `keyboard-quit'
237   ;; to avoid deactivating mark in current-buffer.
238   (let ((debug-on-quit nil))
239     (signal 'quit nil)))
240
241 (cl-defun helm-comp-read-get-candidates (collection &optional
242                                                     test sort-fn alistp
243                                                     (input helm-pattern))
244   "Convert COLLECTION to list removing elements that don't match TEST.
245 See `helm-comp-read' about supported COLLECTION arguments.
246
247 SORT-FN is a predicate to sort COLLECTION.
248
249 ALISTP when non--nil will not use `all-completions' to collect
250 candidates because it doesn't handle alists correctly for helm.
251 i.e In `all-completions' the car of each pair is used as value.
252 In helm we want to use the cdr instead like \(display . real\),
253 so we return the alist as it is with no transformation by
254 `all-completions'.
255
256 e.g
257
258 \(setq A '((a . 1) (b . 2) (c . 3)))
259 ==>((a . 1) (b . 2) (c . 3))
260 \(helm-comp-read \"test: \" A :alistp nil
261                               :exec-when-only-one t
262                               :initial-input \"a\")
263 ==>\"a\" Which is not what we expect.
264
265 \(helm-comp-read \"test: \" A :alistp t
266                               :exec-when-only-one t
267                               :initial-input \"1\")
268 ==>\"1\"
269
270 See docstring of `all-completions' for more info.
271
272 INPUT is the string you want to complete against, defaulting to
273 `helm-pattern' which is the value of what you enter in minibuffer.
274 Note that when using a function as COLLECTION this value will be
275 available with the input argument of the function only when using a
276 sync source from `helm-comp-read', i.e not using
277 `:candidates-in-buffer', otherwise the function is called only once
278 with an empty string as value for `helm-pattern' because
279 `helm-pattern' is not yet computed, which is what we want otherwise
280 data would not be fully collected at init time.
281
282 If COLLECTION is an `obarray', a TEST should be needed. See `obarray'."
283   ;; Ensure COLLECTION is computed from `helm-current-buffer'
284   ;; because some functions used as COLLECTION work
285   ;; only in the context of current-buffer (Issue #1030) .
286   (with-helm-current-buffer
287     (let ((cands
288            (cond ((vectorp collection)
289                   (all-completions input collection test))
290                  ((and (symbolp collection) (boundp collection)
291                        ;; Issue #324 history is let-bounded and given
292                        ;; quoted as hist argument of completing-read.
293                        ;; See example in `rcirc-browse-url'.
294                        (symbolp (symbol-value collection)))
295                   nil)
296                  ;; When collection is a symbol, most of the time
297                  ;; it should be a symbol used as a minibuffer-history.
298                  ;; The value of this symbol in this case return a list
299                  ;; of string which maybe are converted later as symbol
300                  ;; in special cases.
301                  ;; we treat here commandp as a special case as it return t
302                  ;; also with a string unless its last arg is provided.
303                  ;; Also, the history collections generally collect their
304                  ;; elements as string, so intern them to call predicate.
305                  ((and (symbolp collection) (boundp collection) test)
306                   (let ((predicate (lambda (elm)
307                                      (condition-case _err
308                                          (if (eq test 'commandp)
309                                              (funcall test (intern elm))
310                                              (funcall test elm))
311                                        (wrong-type-argument
312                                         (funcall test (intern elm)))))))
313                     (all-completions input (symbol-value collection) predicate)))
314                  ((and (symbolp collection) (boundp collection))
315                   (all-completions input (symbol-value collection)))
316                  ;; Normally file completion should not be handled here,
317                  ;; but special cases like `find-file-at-point' do it.
318                  ;; Handle here specially such cases.
319                  ((and (functionp collection) (not (string= input ""))
320                        minibuffer-completing-file-name)
321                   (cl-loop for f in (funcall collection input test t)
322                            unless (member f '("./" "../"))
323                            if (string-match helm--url-regexp input)
324                            collect f
325                            else
326                            collect (concat (file-name-as-directory
327                                             (helm-basedir input))
328                                            f)))
329                  ((functionp collection)
330                   (funcall collection input test t))
331                  ((and alistp (null test)) collection)
332                  ;; Next test ensure circular objects are removed
333                  ;; with `all-completions' (Issue #1530).
334                  (t (all-completions input collection test)))))
335       (if sort-fn (sort cands sort-fn) cands))))
336
337 (defun helm-cr--pattern-in-candidates-p (candidates)
338   (or (assoc helm-pattern candidates)
339       (assq (intern helm-pattern) candidates)
340       (member helm-pattern candidates)
341       (member (downcase helm-pattern) candidates)
342       (member (upcase helm-pattern) candidates)))
343
344 (defun helm-cr-default-transformer (candidates source)
345   "Default filter candidate function for `helm-comp-read'."
346   (let ((must-match (helm-attr 'must-match source))
347         unknown-pattern)
348     (unless (or (eq must-match t)
349                 (string= helm-pattern "")
350                 (helm-cr--pattern-in-candidates-p candidates))
351       (setq candidates (append (list
352                                 ;; Unquote helm-pattern
353                                 ;; when it is added
354                                 ;; as candidate: Why? #2015
355                                 ;; (replace-regexp-in-string
356                                 ;;  "\\s\\" "" helm-pattern)
357                                 helm-pattern)
358                                candidates))
359       ;; Notify pattern have been added to candidates.
360       (setq unknown-pattern t))
361     (cl-loop for c in candidates
362              for cand = (if (stringp c)
363                             (replace-regexp-in-string "\\s\\" "" c)
364                           c)
365              for pat = (replace-regexp-in-string "\\s\\" "" helm-pattern)
366              if (and (or (equal c pat) (equal c helm-pattern))
367                      unknown-pattern)
368              collect
369              (cons (concat (propertize
370                             " " 'display
371                             (propertize "[?]" 'face 'helm-ff-prefix))
372                            c)
373                    c)
374              into lst
375              else collect (if (and (stringp cand)
376                                    (string-match "\n" cand))
377                               (cons (replace-regexp-in-string "\n" "->" c) c)
378                             c)
379              into lst
380              finally return (helm-fast-remove-dups lst :test 'equal))))
381
382 (defun helm-comp-read--move-to-first-real-candidate ()
383   (helm-aif (helm-get-selection nil 'withprop)
384       (when (string= (get-text-property 0 'display it) "[?]")
385         (helm-next-line))))
386
387 (defun helm-cr-default (default cands)
388   (delq nil
389         (cond ((and (stringp default) (not (string= default "")))
390                (cons default (delete default cands)))
391               ((consp default)
392                (append (cl-loop for d in default
393                                 ;; Don't convert
394                                 ;; nil to "nil" (i.e the string)
395                                 ;; it will be delq'ed on top.
396                                 collect (if (null d) d (helm-stringify d)))
397                        cands))
398               (t cands))))
399
400 ;;;###autoload
401 (cl-defun helm-comp-read (prompt collection
402                           &key
403                             test
404                             initial-input
405                             default
406                             preselect
407                             (buffer "*Helm Completions*")
408                             must-match
409                             fuzzy
410                             reverse-history
411                             (requires-pattern 0)
412                             history
413                             input-history
414                             (case-fold helm-comp-read-case-fold-search)
415                             (del-input t)
416                             (persistent-action nil)
417                             (persistent-help "DoNothing")
418                             (mode-line helm-comp-read-mode-line)
419                             help-message
420                             (keymap helm-comp-read-map)
421                             (name "Helm Completions")
422                             header-name
423                             candidates-in-buffer
424                             match-part
425                             exec-when-only-one
426                             quit-when-no-cand
427                             (volatile t)
428                             sort
429                             fc-transformer
430                             hist-fc-transformer
431                             marked-candidates
432                             nomark
433                             (alistp t)
434                             (candidate-number-limit helm-candidate-number-limit)
435                             multiline
436                             allow-nest)
437   "Read a string in the minibuffer, with helm completion.
438
439 It is helm `completing-read' equivalent.
440
441 - PROMPT is the prompt name to use.
442
443 - COLLECTION can be a list, vector, obarray or hash-table.
444   It can be also a function that receives three arguments:
445   the values string, predicate and t. See `all-completions' for more details.
446
447 Keys description:
448
449 - TEST: A predicate called with one arg i.e candidate.
450
451 - INITIAL-INPUT: Same as input arg in `helm'.
452
453 - PRESELECT: See preselect arg of `helm'.
454
455 - DEFAULT: This option is used only for compatibility with regular
456   Emacs `completing-read' (Same as DEFAULT arg of `completing-read').
457
458 - BUFFER: Name of helm-buffer.
459
460 - MUST-MATCH: Candidate selected must be one of COLLECTION.
461
462 - FUZZY: Enable fuzzy matching.
463
464 - REVERSE-HISTORY: When non--nil display history source after current
465   source completion.
466
467 - REQUIRES-PATTERN: Same as helm attribute, default is 0.
468
469 - HISTORY: A list containing specific history, default is nil.
470   When it is non--nil, all elements of HISTORY are displayed in
471   a special source before COLLECTION.
472
473 - INPUT-HISTORY: A symbol. the minibuffer input history will be
474   stored there, if nil or not provided, `minibuffer-history'
475   will be used instead.
476
477 - CASE-FOLD: Same as `helm-case-fold-search'.
478
479 - DEL-INPUT: Boolean, when non--nil (default) remove the partial
480   minibuffer input from HISTORY is present.
481
482 - PERSISTENT-ACTION: A function called with one arg i.e candidate.
483
484 - PERSISTENT-HELP: A string to document PERSISTENT-ACTION.
485
486 - MODE-LINE: A string or list to display in mode line.
487   Default is `helm-comp-read-mode-line'.
488
489 - KEYMAP: A keymap to use in this `helm-comp-read'.
490   (the keymap will be shared with history source)
491
492 - NAME: The name related to this local source.
493
494 - HEADER-NAME: A function to alter NAME, see `helm'.
495
496 - EXEC-WHEN-ONLY-ONE: Bound `helm-execute-action-at-once-if-one'
497   to non--nil. (possibles values are t or nil).
498
499 - VOLATILE: Use volatile attribute.
500
501 - SORT: A predicate to give to `sort' e.g `string-lessp'
502   Use this only on small data as it is ineficient.
503   If you want to sort faster add a sort function to
504   FC-TRANSFORMER.
505   Note that FUZZY when enabled is already providing a sort function.
506
507 - FC-TRANSFORMER: A `filtered-candidate-transformer' function
508   or a list of functions.
509
510 - HIST-FC-TRANSFORMER: A `filtered-candidate-transformer'
511   function for the history source.
512
513 - MARKED-CANDIDATES: If non--nil return candidate or marked candidates as a list.
514
515 - NOMARK: When non--nil don't allow marking candidates.
516
517 - ALISTP: \(default is non--nil\) See `helm-comp-read-get-candidates'.
518
519 - CANDIDATES-IN-BUFFER: when non--nil use a source build with
520   `helm-source-in-buffer' which is much faster.
521   Argument VOLATILE have no effect when CANDIDATES-IN-BUFFER is non--nil.
522
523 - MATCH-PART: Allow matching only one part of candidate.
524   See match-part documentation in `helm-source'.
525
526 - ALLOW-NEST: Allow nesting this `helm-comp-read' in a helm session.
527   See `helm'.
528
529 - MULTILINE: See multiline in `helm-source'.
530
531 Any prefix args passed during `helm-comp-read' invocation will be recorded
532 in `helm-current-prefix-arg', otherwise if prefix args were given before
533 `helm-comp-read' invocation, the value of `current-prefix-arg' will be used.
534 That's mean you can pass prefix args before or after calling a command
535 that use `helm-comp-read' See `helm-M-x' for example."
536
537   (when (get-buffer helm-action-buffer)
538     (kill-buffer helm-action-buffer))
539   (let ((action-fn `(("Sole action (Identity)"
540                       . (lambda (candidate)
541                           (if ,marked-candidates
542                               (helm-marked-candidates)
543                               (identity candidate)))))))
544     ;; Assume completion have been already required,
545     ;; so always use 'confirm.
546     (when (eq must-match 'confirm-after-completion)
547       (setq must-match 'confirm))
548     (let* ((minibuffer-completion-confirm must-match)
549            (must-match-map (when must-match
550                              (let ((map (make-sparse-keymap)))
551                                (define-key map (kbd "RET")
552                                  'helm-confirm-and-exit-minibuffer)
553                                map)))
554            (loc-map (if must-match-map
555                         (make-composed-keymap
556                          must-match-map (or keymap helm-map))
557                       (or keymap helm-map)))
558            (minibuffer-completion-predicate test)
559            (minibuffer-completion-table collection)
560            (helm-read-file-name-mode-line-string
561             (replace-regexp-in-string "helm-maybe-exit-minibuffer"
562                                       "helm-confirm-and-exit-minibuffer"
563                                       helm-read-file-name-mode-line-string))
564            (get-candidates
565             (lambda ()
566               (let ((cands (helm-comp-read-get-candidates
567                             collection test sort alistp
568                             ;; This should not be needed as
569                             ;; `helm-pattern' is not yet computed when
570                             ;; calling this from :init when
571                             ;; candidates-in-buffer is in use.
572                             (if candidates-in-buffer "" helm-pattern))))
573                 (helm-cr-default default cands))))
574            (history-get-candidates
575             (lambda ()
576               (let ((cands (helm-comp-read-get-candidates
577                             history test nil alistp)))
578                 (when cands
579                   (delete "" (helm-cr-default default cands))))))
580            (src-hist (helm-build-sync-source (format "%s History" name)
581                        :candidates history-get-candidates
582                        :fuzzy-match fuzzy
583                        :multiline multiline
584                        :match-part match-part
585                        :filtered-candidate-transformer
586                        (append '((lambda (candidates sources)
587                                    (cl-loop for i in candidates
588                                             ;; Input is added to history in completing-read's
589                                             ;; and may be regexp-quoted, so unquote it
590                                             ;; but check if cand is a string (it may be at this stage
591                                             ;; a symbol or nil) Issue #1553.
592                                             when (stringp i)
593                                             collect (replace-regexp-in-string "\\s\\" "" i))))
594                                (and hist-fc-transformer (helm-mklist hist-fc-transformer)))
595                        :persistent-action persistent-action
596                        :persistent-help persistent-help
597                        :keymap loc-map
598                        :mode-line mode-line
599                        :help-message help-message
600                        :action action-fn))
601            (src (helm-build-sync-source name
602                   :candidates get-candidates
603                   :match-part match-part
604                   :multiline multiline
605                   :header-name header-name
606                   :filtered-candidate-transformer
607                   (append (helm-mklist fc-transformer)
608                           '(helm-cr-default-transformer))
609                   :requires-pattern requires-pattern
610                   :persistent-action persistent-action
611                   :persistent-help persistent-help
612                   :fuzzy-match fuzzy
613                   :keymap loc-map
614                   :mode-line mode-line
615                   :help-message help-message
616                   :action action-fn
617                   :volatile volatile))
618            (src-1 (helm-build-in-buffer-source name
619                     :data get-candidates
620                     :match-part match-part
621                     :multiline multiline
622                     :header-name header-name
623                     :filtered-candidate-transformer
624                     (append (helm-mklist fc-transformer)
625                             '(helm-cr-default-transformer))
626                     :requires-pattern requires-pattern
627                     :persistent-action persistent-action
628                     :fuzzy-match fuzzy
629                     :keymap loc-map
630                     :persistent-help persistent-help
631                     :mode-line mode-line
632                     :help-message help-message
633                     :action action-fn))
634            (src-list (list src-hist
635                            (cons (cons 'must-match must-match)
636                                  (if candidates-in-buffer
637                                      src-1 src))))
638            (helm-execute-action-at-once-if-one exec-when-only-one)
639            (helm-quit-if-no-candidate quit-when-no-cand)
640            result)
641       (when nomark
642         (setq src-list (cl-loop for src in src-list
643                              collect (cons '(nomark) src))))
644       (when reverse-history (setq src-list (nreverse src-list)))
645       (add-hook 'helm-after-update-hook 'helm-comp-read--move-to-first-real-candidate)
646       (unwind-protect
647            (setq result (helm
648                          :sources src-list
649                          :input initial-input
650                          :default default
651                          :preselect preselect
652                          :prompt prompt
653                          :resume 'noresume
654                          :keymap loc-map ;; Needed with empty collection.
655                          :allow-nest allow-nest
656                          :candidate-number-limit candidate-number-limit
657                          :case-fold-search case-fold
658                          :history (and (symbolp input-history) input-history)
659                          :buffer buffer))
660         (remove-hook 'helm-after-update-hook 'helm-comp-read--move-to-first-real-candidate))
661       ;; Avoid adding an incomplete input to history.
662       (when (and result history del-input)
663         (cond ((and (symbolp history) ; History is a symbol.
664                     (not (symbolp (symbol-value history)))) ; Fix Issue #324.
665                ;; Be sure history is not a symbol with a nil value.
666                (helm-aif (symbol-value history) (setcar it result)))
667               ((consp history) ; A list with a non--nil value.
668                (setcar history result))
669               (t ; Possibly a symbol with a nil value.
670                (set history (list result)))))
671       (or result (helm-mode--keyboard-quit)))))
672
673
674 ;; Generic completing-read
675 ;;
676 ;; Support also function as collection.
677 ;; e.g M-x man is supported.
678 ;; Support hash-table and vectors as collection.
679 ;; NOTE:
680 ;; Some crap emacs functions may not be supported
681 ;; like ffap-alternate-file (bad use of completing-read)
682 ;; and maybe others.
683 ;; Provide a mode `helm-mode' which turn on
684 ;; helm in all `completing-read' and `read-file-name' in Emacs.
685 ;;
686 (defvar helm-completion-mode-string " Helm")
687
688 (defvar helm-completion-mode-quit-message
689   "Helm completion disabled")
690
691 (defvar helm-completion-mode-start-message
692   "Helm completion enabled")
693
694 ;;; Specialized handlers
695 ;;
696 ;;
697 (defun helm-completing-read-symbols
698     (prompt _collection test _require-match init
699      hist default _inherit-input-method name buffer)
700   "Specialized function for fast symbols completion in `helm-mode'."
701   (require 'helm-elisp)
702   (or
703    (helm
704     :sources (helm-build-in-buffer-source name
705                :init (lambda ()
706                        (helm-apropos-init (lambda (x)
707                                             (and (funcall test x)
708                                                  (not (keywordp x))))
709                                           (or (car-safe default) default)))
710                :filtered-candidate-transformer 'helm-apropos-default-sort-fn
711                :help-message #'helm-comp-read-help-message
712                :fuzzy-match helm-mode-fuzzy-match
713                :persistent-action
714                (lambda (candidate)
715                  (helm-lisp-completion-persistent-action
716                   candidate name))
717                :persistent-help (helm-lisp-completion-persistent-help))
718     :prompt prompt
719     :buffer buffer
720     :input init
721     :history hist
722     :resume 'noresume
723     :default (or default ""))
724      (helm-mode--keyboard-quit)))
725
726
727 ;;; Generic completing read
728 ;;
729 ;;
730 (defun helm-completing-read-default-1
731     (prompt collection test require-match
732      init hist default _inherit-input-method
733      name buffer &optional cands-in-buffer exec-when-only-one)
734   "Call `helm-comp-read' with same args as `completing-read'.
735 Extra optional arg CANDS-IN-BUFFER mean use `candidates-in-buffer'
736 method which is faster.
737 It should be used when candidate list don't need to rebuild dynamically."
738   (let ((history (or (car-safe hist) hist))
739         (initial-input (helm-aif (pcase init
740                                    ((pred (stringp)) init)
741                                    ;; INIT is a cons cell.
742                                    (`(,l . ,_ll) l))
743                            (if minibuffer-completing-file-name it
744                                (regexp-quote it)))))
745     (helm-comp-read
746      prompt collection
747      :test test
748      :history history
749      :reverse-history helm-mode-reverse-history
750      :input-history history
751      :must-match require-match
752      :alistp nil
753      :help-message #'helm-comp-read-help-message
754      :name name
755      :requires-pattern (if (and (stringp default)
756                                 (string= default "")
757                                 (or (eq require-match 'confirm)
758                                     (eq require-match
759                                         'confirm-after-completion)))
760                            1 0)
761      :candidates-in-buffer cands-in-buffer
762      :exec-when-only-one exec-when-only-one
763      :fuzzy helm-mode-fuzzy-match
764      :buffer buffer
765      ;; If DEF is not provided, fallback to empty string
766      ;; to avoid `thing-at-point' to be appended on top of list
767      :default (or default "")
768      ;; Fail with special characters (e.g in gnus "nnimap+gmail:")
769      ;; if regexp-quote is not used.
770      ;; when init is added to history, it will be unquoted by
771      ;; helm-comp-read.
772      :initial-input initial-input)))
773
774 (defun helm-completing-read-default-find-tag
775     (prompt collection test require-match
776      init hist default inherit-input-method
777      name buffer)
778   "Specialized `helm-mode' handler for `find-tag'."
779   ;; Some commands like find-tag may use `read-file-name' from inside
780   ;; the calculation of collection. in this case it clash with
781   ;; candidates-in-buffer that reuse precedent data (files) which is wrong.
782   ;; So (re)calculate collection outside of main helm-session.
783   (let* ((cands (helm-comp-read-get-candidates
784                  collection test nil nil)))
785     (helm-completing-read-default-1 prompt cands test require-match
786                                     init hist default inherit-input-method
787                                     name buffer t)))
788
789 (defun helm-completing-read-sync-default-handler
790     (prompt collection test require-match
791      init hist default inherit-input-method
792      name buffer)
793   "`helm-mode' handler using sync source as backend."
794   (helm-completing-read-default-1 prompt collection test require-match
795                                   init hist default inherit-input-method
796                                   name buffer))
797
798 (defun helm-completing-read-default-handler
799     (prompt collection test require-match
800      init hist default inherit-input-method
801      name buffer)
802   "Default `helm-mode' handler for all `completing-read'."
803   (helm-completing-read-default-1 prompt collection test require-match
804                                   init hist default inherit-input-method
805                                   name buffer
806                                   (null helm-completing-read-dynamic-complete)))
807
808 (defun helm--generic-read-buffer (prompt &optional default require-match predicate)
809   "The `read-buffer-function' for `helm-mode'.
810 Affects `switch-to-buffer' and related."
811   (let ((collection (helm-buffer-list)))
812     (helm--completing-read-default
813      prompt collection predicate require-match nil nil default)))
814
815 (cl-defun helm--completing-read-default
816     (prompt collection &optional
817                          predicate require-match
818                          initial-input hist def
819                          inherit-input-method)
820   "An helm replacement of `completing-read'.
821 This function should be used only as a `completing-read-function'.
822
823 Don't use it directly, use instead `helm-comp-read' in your programs.
824
825 See documentation of `completing-read' and `all-completions' for details."
826   (let* ((current-command (or (helm-this-command) this-command))
827          (str-command     (helm-symbol-name current-command))
828          (buf-name        (format "*helm-mode-%s*" str-command))
829          (entry           (assq current-command
830                                 helm-completing-read-handlers-alist))
831          (def-com         (cdr-safe entry))
832          (str-defcom      (and def-com (helm-symbol-name def-com)))
833          (def-args        (list prompt collection predicate require-match
834                                 initial-input hist def inherit-input-method))
835          ;; Append the two extra args needed to set the buffer and source name
836          ;; in helm specialized functions.
837          (any-args        (append def-args (list str-command buf-name)))
838          helm-completion-mode-start-message ; Be quiet
839          helm-completion-mode-quit-message
840          ;; Be sure this pesty *completion* buffer doesn't popup.
841          ;; Note: `minibuffer-with-setup-hook' may setup a lambda
842          ;; calling `minibuffer-completion-help' or other minibuffer
843          ;; functions we DONT WANT here, in these cases removing the hook
844          ;; (a symbol) have no effect. Issue #448.
845          ;; Because `minibuffer-completion-table' and
846          ;; `minibuffer-completion-predicate' are not bound
847          ;; anymore here, these functions should have no effect now,
848          ;; except in some rare cases like in `woman-file-name',
849          ;; so remove all incompatible functions
850          ;; from `minibuffer-setup-hook' (Issue #1205, #1240).
851          ;; otherwise helm have not the time to close its initial session.
852          (minibuffer-setup-hook
853           (cl-loop for h in minibuffer-setup-hook
854                    unless (or (consp h) ; a lambda.
855                               (byte-code-function-p h)
856                               (memq h helm-mode-minibuffer-setup-hook-black-list))
857                    collect h))
858          ;; Disable hack that could be used before `completing-read'.
859          ;; i.e (push ?\t unread-command-events).
860          unread-command-events
861          (default-handler
862           ;; Typically when COLLECTION is a function, we can assume
863           ;; the intention is completing dynamically according to
864           ;; input; If one want to use in-buffer handler for specific
865           ;; usage with a function as collection he can specify it in
866           ;; helm-completing-read-handlers-alist.
867           (if (functionp collection)
868               #'helm-completing-read-sync-default-handler
869             #'helm-completing-read-default-handler)))
870     (when (eq def-com 'ido) (setq def-com 'ido-completing-read))
871     (unless (or (not entry) def-com)
872       ;; An entry in *read-handlers-alist exists but have
873       ;; a nil value, so we exit from here, disable `helm-mode'
874       ;; and run the command again with it original behavior.
875       ;; `helm-mode' will be restored on exit.
876       (cl-return-from helm--completing-read-default
877         (unwind-protect
878              (progn
879                (helm-mode -1)
880                (apply completing-read-function def-args))
881           (helm-mode 1))))
882     ;; If we use now `completing-read' we MUST turn off `helm-mode'
883     ;; to avoid infinite recursion and CRASH. It will be reenabled on exit.
884     (when (or (eq def-com 'completing-read)
885               ;; All specialized functions are prefixed by "helm"
886               (and (stringp str-defcom)
887                    (not (string-match "^helm" str-defcom))))
888       (helm-mode -1))
889     (unwind-protect
890          (cond (;; An helm specialized function exists, run it.
891                 (and def-com helm-mode)
892                 (apply def-com any-args))
893                (;; Try to handle `ido-completing-read' everywhere.
894                 (and def-com (eq def-com 'ido-completing-read))
895                 (setcar (memq collection def-args)
896                         (all-completions "" collection predicate))
897                 (apply def-com def-args))
898                (;; User set explicitely `completing-read' or something similar
899                 ;; in *read-handlers-alist, use this with exactly the same
900                 ;; args as in `completing-read'.
901                 ;; If we are here `helm-mode' is now disabled.
902                 def-com
903                 (apply def-com def-args))
904                (;; Use by default a in-buffer handler unless
905                 ;; COLLECTION is a function. 
906                 t
907                 (funcall default-handler
908                          prompt collection predicate require-match
909                          initial-input hist def inherit-input-method
910                          str-command buf-name)))
911       (helm-mode 1)
912       ;; When exiting minibuffer, `this-command' is set to
913       ;; `helm-exit-minibuffer', which is unwanted when starting
914       ;; on another `completing-read', so restore `this-command' to
915       ;; initial value when exiting.
916       (setq this-command current-command))))
917
918 ;;; Generic read-file-name
919 ;;
920 ;;
921 ;;;###autoload
922 (cl-defun helm-read-file-name
923     (prompt
924      &key
925        (name "Read File Name")
926        (initial-input default-directory)
927        (buffer "*Helm file completions*")
928        test
929        (case-fold helm-file-name-case-fold-search)
930        preselect
931        history
932        must-match
933        (fuzzy t)
934        default
935        marked-candidates
936        (candidate-number-limit helm-ff-candidate-number-limit)
937        nomark
938        (alistp t)
939        (persistent-action-if 'helm-find-files-persistent-action-if)
940        (persistent-help "Hit1 Expand Candidate, Hit2 or (C-u) Find file")
941        (mode-line helm-read-file-name-mode-line-string))
942   "Read a file name with helm completion.
943 It is helm `read-file-name' emulation.
944
945 Argument PROMPT is the default prompt to use.
946
947 Keys description:
948
949 - NAME: Source name, default to \"Read File Name\".
950
951 - INITIAL-INPUT: Where to start read file name, default to `default-directory'.
952
953 - BUFFER: `helm-buffer' name default to \"*Helm Completions*\".
954
955 - TEST: A predicate called with one arg 'candidate'.
956
957 - CASE-FOLD: Same as `helm-case-fold-search'.
958
959 - PRESELECT: helm preselection.
960
961 - HISTORY: Display HISTORY in a special source.
962
963 - MUST-MATCH: Can be 'confirm, nil, or t.
964
965 - FUZZY: Enable fuzzy matching when non-nil (Enabled by default).
966
967 - MARKED-CANDIDATES: When non--nil return a list of marked candidates.
968
969 - NOMARK: When non--nil don't allow marking candidates.
970
971 - ALISTP: Don't use `all-completions' in history (take effect only on history).
972
973 - PERSISTENT-ACTION-IF: a persistent if action function.
974
975 - PERSISTENT-HELP: persistent help message.
976
977 - MODE-LINE: A mode line message, default is `helm-read-file-name-mode-line-string'."
978   (require 'tramp)
979   (when (get-buffer helm-action-buffer)
980     (kill-buffer helm-action-buffer))
981   ;; Assume completion have been already required,
982   ;; so always use 'confirm.
983   (when (eq must-match 'confirm-after-completion)
984     (setq must-match 'confirm))
985   (mapc (lambda (hook)
986           (add-hook 'helm-after-update-hook hook))
987         '(helm-ff-move-to-first-real-candidate
988           helm-ff-update-when-only-one-matched
989           helm-ff-auto-expand-to-home-or-root))
990   (let* ((action-fn `(("Sole action (Identity)"
991                        . (lambda (candidate)
992                            (if ,marked-candidates
993                                (helm-marked-candidates :with-wildcard t)
994                              (identity candidate))))))
995          ;; Be sure we don't erase the underlying minibuffer if some.
996          (helm-ff-auto-update-initial-value
997           (and helm-ff-auto-update-initial-value
998                (not (minibuffer-window-active-p (minibuffer-window)))))
999          helm-follow-mode-persistent
1000          (helm-ff-fuzzy-matching
1001           (and fuzzy
1002                (not (memq helm-mm-matching-method '(multi1 multi3p)))))
1003          (hist (and history (helm-comp-read-get-candidates
1004                              history nil nil alistp)))
1005          (minibuffer-completion-confirm must-match)
1006          (must-match-map (when must-match
1007                            (let ((map (make-sparse-keymap)))
1008                              (define-key map (kbd "RET")
1009                                (let ((fn (lookup-key helm-read-file-map (kbd "RET"))))
1010                                  (if (eq fn 'helm-ff-RET)
1011                                      #'helm-ff-RET-must-match
1012                                    #'helm-confirm-and-exit-minibuffer)))
1013                              map)))
1014          (cmap (if must-match-map
1015                    (make-composed-keymap
1016                     must-match-map helm-read-file-map)
1017                  helm-read-file-map))
1018          (minibuffer-completion-predicate test)
1019          (minibuffer-completing-file-name t)
1020          (helm--completing-file-name t)
1021          (helm-read-file-name-mode-line-string
1022           (replace-regexp-in-string "helm-maybe-exit-minibuffer"
1023                                     "helm-confirm-and-exit-minibuffer"
1024                                     helm-read-file-name-mode-line-string))
1025          (src-list
1026           (list
1027            ;; History source.
1028            (helm-build-sync-source (format "%s History" name)
1029              :header-name (lambda (name)
1030                             (concat name (substitute-command-keys
1031                                           helm-find-files-doc-header)))
1032              :mode-line mode-line
1033              :candidates hist
1034              :nohighlight t
1035              :fuzzy-match fuzzy
1036              :persistent-action-if persistent-action-if
1037              :persistent-help persistent-help
1038              :keymap cmap
1039              :nomark nomark
1040              :action action-fn)
1041            ;; Other source.
1042            (helm-build-sync-source name
1043              :header-name (lambda (name)
1044                             (concat name (substitute-command-keys
1045                                           helm-find-files-doc-header)))
1046              :init (lambda ()
1047                      (setq helm-ff-auto-update-flag
1048                            helm-ff-auto-update-initial-value)
1049                      (setq helm-ff--auto-update-state
1050                            helm-ff-auto-update-flag))
1051              :mode-line mode-line
1052              :help-message 'helm-read-file-name-help-message
1053              :nohighlight t
1054              :candidates
1055              (lambda ()
1056                (append (and (not (file-exists-p helm-pattern))
1057                             (not (helm-ff--invalid-tramp-name-p helm-pattern))
1058                             (list helm-pattern))
1059                        (if test
1060                            (cl-loop with hn = (helm-ff--tramp-hostnames)
1061                                     for i in (helm-find-files-get-candidates
1062                                               must-match)
1063                                     when (or (member i hn) ; A tramp host
1064                                              (funcall test i)) ; Test ok
1065                                     collect i)
1066                            (helm-find-files-get-candidates must-match))))
1067              :filtered-candidate-transformer 'helm-ff-sort-candidates
1068              :filter-one-by-one 'helm-ff-filter-candidate-one-by-one
1069              :persistent-action-if persistent-action-if
1070              :persistent-help persistent-help
1071              :volatile t
1072              :keymap cmap
1073              :cleanup 'helm-find-files-cleanup
1074              :nomark nomark
1075              :action action-fn)))
1076          ;; Helm result.
1077          (result (helm
1078                   :sources (if helm-mode-reverse-history
1079                                (reverse src-list) src-list)
1080                   :input (expand-file-name initial-input)
1081                   :prompt prompt
1082                   :candidate-number-limit candidate-number-limit
1083                   :resume 'noresume
1084                   :case-fold-search case-fold
1085                   :default default
1086                   :buffer buffer
1087                   :full-frame nil
1088                   :preselect preselect)))
1089     (or
1090      (cond ((and result (stringp result)
1091                  (string= result "") ""))
1092            ((and result
1093                  (stringp result)
1094                  (file-equal-p result initial-input)
1095                  default)
1096             (if (listp default) (car default) default))
1097            ((and result (listp result))
1098             (mapcar #'expand-file-name result))
1099            ((and result (file-directory-p result))
1100             (file-name-as-directory (expand-file-name result)))
1101            (result (expand-file-name result)))
1102      (helm-mode--keyboard-quit))))
1103
1104 (defun helm-mode--default-filename (fname dir initial)
1105   (unless dir (setq dir default-directory))
1106   (unless (file-name-absolute-p dir)
1107     (setq dir (expand-file-name dir)))
1108   (unless (or fname (consp fname))
1109     (setq fname (expand-file-name
1110                  (or initial buffer-file-name dir)
1111                  dir)))
1112   (if (and fname (consp fname))
1113       (setq fname (cl-loop for f in fname
1114                            collect (expand-file-name f dir)))
1115       (if (file-name-absolute-p fname)
1116           fname (expand-file-name fname dir))))
1117
1118 (cl-defun helm--generic-read-file-name
1119     (prompt &optional dir default-filename mustmatch initial predicate)
1120   "Generic helm replacement of `read-file-name'.
1121 Don't use it directly, use instead `helm-read-file-name' in your programs."
1122   (let* ((init (or initial dir default-directory))
1123          (current-command (or (helm-this-command) this-command))
1124          (str-command (helm-symbol-name current-command))
1125          (helm--file-completion-sources
1126           (cons str-command
1127                 (remove str-command helm--file-completion-sources)))
1128          (buf-name (format "*helm-mode-%s*" str-command))
1129          (entry (assq current-command
1130                       helm-completing-read-handlers-alist))
1131          (def-com  (cdr-safe entry))
1132          (str-defcom (and def-com (helm-symbol-name def-com)))
1133          ;; Don't modify the original args list for emacs generic functions.
1134          (def-args (list prompt dir default-filename mustmatch initial predicate))
1135          ;; Append the two extra args needed to set the buffer and source name
1136          ;; in helm specialized functions.
1137          (any-args (append def-args (list str-command buf-name)))
1138          (ido-state ido-mode)
1139          helm-completion-mode-start-message ; Be quiet
1140          helm-completion-mode-quit-message  ; Same here
1141          fname)
1142     ;; Build `default-filename' with `dir'+`initial' when
1143     ;; `default-filename' is not specified.
1144     ;; See `read-file-name' docstring for more infos.
1145     (setq default-filename (helm-mode--default-filename
1146                             default-filename dir initial))
1147     ;; Some functions that normally call `completing-read' can switch
1148     ;; brutally to `read-file-name' (e.g find-tag), in this case
1149     ;; the helm specialized function will fail because it is build
1150     ;; for `completing-read', so set it to 'incompatible to be sure
1151     ;; we switch to `helm-read-file-name' and don't try to call it
1152     ;; with wrong number of args.
1153     (when (eq def-com 'ido)
1154       (setq def-com 'ido-read-file-name) (ido-mode 1))
1155     (when (and def-com (> (length (help-function-arglist def-com)) 8))
1156       (setq def-com 'incompatible))
1157     (unless (or (not entry) def-com)
1158       (cl-return-from helm--generic-read-file-name
1159         (unwind-protect
1160              (progn
1161                (helm-mode -1)
1162                (apply read-file-name-function def-args))
1163           (helm-mode 1))))
1164     ;; If we use now `read-file-name' we MUST turn off `helm-mode'
1165     ;; to avoid infinite recursion and CRASH. It will be reenabled on exit.
1166     (when (or (eq def-com 'read-file-name)
1167               (eq def-com 'ido-read-file-name)
1168               (and (stringp str-defcom)
1169                    (not (string-match "^helm" str-defcom))))
1170       (helm-mode -1))
1171     (unwind-protect
1172          (setq fname
1173                (cond (;; A specialized function exists, run it
1174                       ;; with the two extra args specific to helm.
1175                       ;; Note that the helm handler should ensure
1176                       ;; :initial-input is not nil i.e. Use init
1177                       ;; which fallback to default-directory instead
1178                       ;; of INITIAL.
1179                       (and def-com helm-mode
1180                            (not (eq def-com 'ido-read-file-name))
1181                            (not (eq def-com 'incompatible)))
1182                       (apply def-com any-args))
1183                      (;; Def-com value is `ido-read-file-name'
1184                       ;; run it with default args.
1185                       (and def-com (eq def-com 'ido-read-file-name))
1186                       (ido-mode 1)
1187                       (apply def-com def-args))
1188                      (;; Def-com value is `read-file-name'
1189                       ;; run it with default args.
1190                       (eq def-com 'read-file-name)
1191                       (apply def-com def-args))
1192                      (t ; Fall back to classic `helm-read-file-name'.
1193                       (helm-read-file-name
1194                        prompt
1195                        :name str-command
1196                        :buffer buf-name
1197                        :default default-filename
1198                        ;; Helm handlers should always have a non nil INITIAL arg.
1199                        :initial-input (expand-file-name init dir)
1200                        :alistp nil
1201                        :must-match mustmatch
1202                        :test predicate))))
1203       (helm-mode 1)
1204       (ido-mode (if ido-state 1 -1))
1205       ;; Same comment as in `helm--completing-read-default'.
1206       (setq this-command current-command))
1207     (if (and
1208          ;; Using `read-directory-name'.
1209          (eq predicate 'file-directory-p)
1210          ;; `file-name-as-directory' return "./" when FNAME is
1211          ;; empty string.
1212          (not (string= fname "")))
1213         (file-name-as-directory fname) fname)))
1214
1215 ;; Read file name handler with history (issue #1652)
1216 (defun helm-read-file-name-handler-1 (prompt dir default-filename
1217                                       mustmatch initial predicate
1218                                       name buffer)
1219   "A `read-file-name' handler with history.
1220 Can be added to `helm-completing-read-handlers-alist' for functions
1221 that need a `read-file-name' function with directory history.
1222 The `helm-find-files' history `helm-ff-history' is used here."
1223   (let ((helm-always-two-windows t)
1224         (helm-split-window-default-side
1225          (if (eq helm-split-window-default-side 'same)
1226              'below helm-split-window-default-side))
1227         helm-split-window-inside-p
1228         helm-reuse-last-window-split-state
1229         ;; Helm handlers should always have a non nil INITIAL arg.
1230         (init (or initial dir default-directory)))
1231     (helm-read-file-name
1232      prompt
1233      :name name
1234      :history helm-ff-history
1235      :buffer buffer
1236      :default default-filename
1237      :initial-input (expand-file-name init dir)
1238      :alistp nil
1239      :must-match mustmatch
1240      :test predicate)))
1241
1242
1243 ;;; Completion in region
1244 ;;
1245 (defun helm-mode--advice-lisp--local-variables (old--fn &rest args)
1246   (ignore-errors
1247     (apply old--fn args)))
1248
1249 (defun helm-completion-in-region-sort-fn (candidates _source)
1250   "Default sort function for completion-in-region."
1251   (sort candidates 'helm-generic-sort-fn))
1252
1253 (defun helm--completion-in-region (start end collection &optional predicate)
1254   "Helm replacement of `completion--in-region'.
1255 Can be used as value for `completion-in-region-function'."
1256   (cl-declare (special require-match prompt))
1257   (if (memq major-mode helm-mode-no-completion-in-region-in-modes)
1258       (funcall helm--old-completion-in-region-function
1259                start end collection predicate)
1260     (advice-add
1261      'lisp--local-variables
1262      :around #'helm-mode--advice-lisp--local-variables)
1263     (unwind-protect
1264         (let* ((enable-recursive-minibuffers t)
1265                (input (buffer-substring-no-properties start end))
1266                (current-command (or (helm-this-command) this-command))
1267                (crm (eq current-command 'crm-complete))
1268                (str-command (helm-symbol-name current-command))
1269                (buf-name (format "*helm-mode-%s*" str-command))
1270                (require-match (or (and (boundp 'require-match) require-match)
1271                                   minibuffer-completion-confirm
1272                                   ;; If prompt have not been propagated here, that's
1273                                   ;; probably mean we have no prompt and we are in
1274                                   ;; completion-at-point or friend, so use a non--nil
1275                                   ;; value for require-match.
1276                                   (not (boundp 'prompt))))
1277                ;; `completion-extra-properties' is let-bounded in `completion-at-point'.
1278                ;; `afun' is a closure to call against each string in `data'.
1279                ;; it provide the annotation info for each string.
1280                ;; e.g "foo" => "foo <f>" where foo is a function.
1281                ;; See Issue #407.
1282                (afun (plist-get completion-extra-properties :annotation-function))
1283                (metadata (completion-metadata
1284                           (buffer-substring-no-properties start (point))
1285                           collection predicate))
1286                (data (completion-all-completions
1287                       (buffer-substring start end)
1288                       collection
1289                       predicate
1290                       (- (point) start)
1291                       metadata))
1292                ;; `completion-all-completions' store the base-size in the last `cdr',
1293                ;; so data looks like this: '(a b c d . 0) and (last data) == (d . 0).
1294                (last-data (last data))
1295                (base-size (helm-aif (cdr (last data))
1296                               (prog1 it
1297                                 (setcdr last-data nil))
1298                             0))
1299                (init-space-suffix (unless (or helm-completion-in-region-fuzzy-match
1300                                               (string-suffix-p " " input)
1301                                               (string= input ""))
1302                                     " "))
1303                (file-comp-p (or (eq (completion-metadata-get metadata 'category) 'file)
1304                                 (helm-mode--in-file-completion-p)
1305                                 ;; Assume that when `afun' and `predicate' are null
1306                                 ;; we are in filename completion.
1307                                 (and (null afun) (null predicate))))
1308                ;; Completion-at-point and friends have no prompt.
1309                (result (if (stringp data)
1310                            data
1311                          (helm-comp-read
1312                           (or (and (boundp 'prompt) prompt) "Pattern: ")
1313                           (if file-comp-p
1314                               (cl-loop for f in data unless
1315                                        (string-match "\\`\\.\\{1,2\\}/\\'" f)
1316                                        collect f)
1317                             (if afun
1318                                 (mapcar (lambda (s)
1319                                           (let ((ann (funcall afun s)))
1320                                             (if ann
1321                                                 (cons
1322                                                  (concat
1323                                                   s
1324                                                   (propertize
1325                                                    " " 'display
1326                                                    (propertize
1327                                                     ann
1328                                                     'face 'completions-annotations)))
1329                                                  s)
1330                                               s)))
1331                                         data)
1332                               data))
1333                           :name str-command
1334                           :fuzzy helm-completion-in-region-fuzzy-match
1335                           :nomark (null crm)
1336                           :marked-candidates crm
1337                           :initial-input
1338                           (cond ((and file-comp-p
1339                                       (not (string-match "/\\'" input)))
1340                                  (concat (helm-basename input)
1341                                          init-space-suffix))
1342                                 ((string-match "/\\'" input) nil)
1343                                 ((or (null require-match)
1344                                      (stringp require-match))
1345                                  input)
1346                                 (t (concat input init-space-suffix)))
1347                           :buffer buf-name
1348                           :fc-transformer (append '(helm-cr-default-transformer)
1349                                                   (unless (or helm-completion-in-region-fuzzy-match
1350                                                               (null helm-completion-in-region-default-sort-fn))
1351                                                     (list helm-completion-in-region-default-sort-fn)))
1352                           :exec-when-only-one t
1353                           :quit-when-no-cand
1354                           (lambda ()
1355                             ;; Delay message to overwrite "Quit".
1356                             (run-with-timer
1357                              0.01 nil
1358                              (lambda ()
1359                                (message "[No matches]")))
1360                             t) ; exit minibuffer immediately.
1361                           :must-match require-match))))
1362           (cond ((stringp result)
1363                  (choose-completion-string
1364                   result (current-buffer)
1365                   (list (+ start base-size) end)
1366                   completion-list-insert-choice-function))
1367                 ((consp result) ; crm.
1368                  (let ((beg (+ start base-size))
1369                        (sep ","))
1370                    ;; Try to find a default separator.
1371                    (save-excursion
1372                      (goto-char beg)
1373                      (when (looking-back crm-separator (1- (point)))
1374                        (setq sep (match-string 0))))
1375                    (funcall completion-list-insert-choice-function
1376                             beg end (mapconcat 'identity result sep))))
1377                 (t nil)))
1378       (advice-remove 'lisp--local-variables
1379                      #'helm-mode--advice-lisp--local-variables))))
1380
1381 (defun helm-mode--in-file-completion-p ()
1382   (with-helm-current-buffer
1383     (run-hook-with-args-until-success 'file-name-at-point-functions)))
1384
1385 (when (boundp 'completion-in-region-function)
1386   (defconst helm--old-completion-in-region-function completion-in-region-function))
1387
1388 ;;;###autoload
1389 (define-minor-mode helm-mode
1390     "Toggle generic helm completion.
1391
1392 All functions in Emacs that use `completing-read'
1393 or `read-file-name' and friends will use helm interface
1394 when this mode is turned on.
1395
1396 However you can modify this behavior for functions of your choice
1397 with `helm-completing-read-handlers-alist'.
1398
1399 Also commands using `completion-in-region' will be helmized when
1400 `helm-mode-handle-completion-in-region' is non nil, you can modify
1401 this behavior with `helm-mode-no-completion-in-region-in-modes'.
1402
1403 Called with a positive arg, turn on unconditionally, with a
1404 negative arg turn off.
1405 You can turn it on with `helm-mode'.
1406
1407 Some crap emacs functions may not be supported,
1408 e.g `ffap-alternate-file' and maybe others
1409 You can add such functions to `helm-completing-read-handlers-alist'
1410 with a nil value.
1411
1412 About `ido-mode':
1413 When you are using `helm-mode', DO NOT use `ido-mode', instead if you
1414 want some commands use `ido', add these commands to
1415 `helm-completing-read-handlers-alist' with `ido' as value.
1416
1417 Note: This mode is incompatible with Emacs23."
1418   :group 'helm-mode
1419   :global t
1420   :lighter helm-completion-mode-string
1421   (cl-assert (boundp 'completing-read-function) nil
1422              "`helm-mode' not available, upgrade to Emacs-24")
1423   (if helm-mode
1424       (if (fboundp 'add-function)
1425           (progn
1426             (add-function :override completing-read-function
1427                           #'helm--completing-read-default)
1428             (add-function :override read-file-name-function
1429                           #'helm--generic-read-file-name)
1430             (add-function :override read-buffer-function
1431                           #'helm--generic-read-buffer)
1432             (when helm-mode-handle-completion-in-region
1433               (add-function :override completion-in-region-function
1434                             #'helm--completion-in-region)))
1435           (setq completing-read-function 'helm--completing-read-default
1436                 read-file-name-function  'helm--generic-read-file-name
1437                 read-buffer-function     'helm--generic-read-buffer)
1438           (when (and (boundp 'completion-in-region-function)
1439                      helm-mode-handle-completion-in-region)
1440             (setq completion-in-region-function #'helm--completion-in-region))
1441           (message helm-completion-mode-start-message))
1442       (if (fboundp 'remove-function)
1443           (progn
1444             (remove-function completing-read-function #'helm--completing-read-default)
1445             (remove-function read-file-name-function #'helm--generic-read-file-name)
1446             (remove-function read-buffer-function #'helm--generic-read-buffer)
1447             (remove-function completion-in-region-function #'helm--completion-in-region))
1448           (setq completing-read-function (and (fboundp 'completing-read-default)
1449                                         'completing-read-default)
1450                 read-file-name-function  (and (fboundp 'read-file-name-default)
1451                                               'read-file-name-default)
1452                 read-buffer-function     (and (fboundp 'read-buffer) 'read-buffer))
1453           (when (and (boundp 'completion-in-region-function)
1454                      (boundp 'helm--old-completion-in-region-function))
1455             (setq completion-in-region-function helm--old-completion-in-region-function))
1456           (message helm-completion-mode-quit-message))))
1457
1458 (provide 'helm-mode)
1459
1460 ;; Local Variables:
1461 ;; byte-compile-warnings: (not obsolete)
1462 ;; coding: utf-8
1463 ;; indent-tabs-mode: nil
1464 ;; End:
1465
1466 ;;; helm-mode.el ends here