1 ;;; counsel.el --- Various completion functions using Ivy -*- lexical-binding: t -*-
3 ;; Copyright (C) 2015 Free Software Foundation, Inc.
5 ;; Author: Oleh Krehel <ohwoeowho@gmail.com>
6 ;; URL: https://github.com/abo-abo/swiper
8 ;; Package-Requires: ((emacs "24.1") (swiper "0.4.0"))
9 ;; Keywords: completion, matching
11 ;; This file is part of GNU Emacs.
13 ;; This file is free software; you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation; either version 3, or (at your option)
18 ;; This program is distributed in the hope that it will be useful,
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ;; GNU General Public License for more details.
23 ;; For a full copy of the GNU General Public License
24 ;; see <http://www.gnu.org/licenses/>.
28 ;; Just call one of the interactive functions in this file to complete
29 ;; the corresponding thing using `ivy'.
31 ;; Currently available: Elisp symbols, Clojure symbols, Git files.
39 "Elisp completion at point."
42 (lambda (str) (all-completions str obarray))))
44 (defvar counsel-describe-map
45 (let ((map (make-sparse-keymap)))
46 (define-key map (kbd "C-.") #'counsel-find-symbol)
47 (define-key map (kbd "C-,") #'counsel--info-lookup-symbol)
50 (defun counsel-find-symbol ()
51 "Jump to the definition of the current symbol."
53 (ivy-set-action #'counsel--find-symbol)
56 (defun counsel--info-lookup-symbol ()
57 "Lookup the current symbol in the info docs."
59 (ivy-set-action #'counsel-info-lookup-symbol)
62 (defun counsel--find-symbol (x)
63 "Find symbol definition that corresponds to string X."
64 (let ((full-name (get-text-property 0 'full-name x)))
66 (find-library full-name)
74 (prin1-to-string sym)))
76 (prin1-to-string sym)))
78 (error "Couldn't fild definition of %s"
81 (defvar counsel-describe-symbol-history nil
82 "History for `counsel-describe-variable' and `counsel-describe-function'.")
84 (defun counsel-symbol-at-point ()
85 "Return current symbol at point as a string."
86 (let ((s (thing-at-point 'symbol)))
88 (if (string-match "\\`[`']?\\(.*\\)'?\\'" s)
93 (defun counsel-describe-variable ()
94 "Forward to `describe-variable'."
96 (let ((enable-recursive-minibuffers t))
102 (when (or (get vv 'variable-documentation)
103 (and (boundp vv) (not (keywordp vv))))
104 (push (symbol-name vv) cands))))
106 :keymap counsel-describe-map
107 :preselect (counsel-symbol-at-point)
108 :history 'counsel-describe-symbol-history
116 (defun counsel-describe-function ()
117 "Forward to `describe-function'."
119 (let ((enable-recursive-minibuffers t))
120 (ivy-read "Describe function: "
125 (push (symbol-name x) cands))))
127 :keymap counsel-describe-map
128 :preselect (counsel-symbol-at-point)
129 :history 'counsel-describe-symbol-history
136 (defvar info-lookup-mode)
137 (declare-function info-lookup->completions "info-look")
138 (declare-function info-lookup->mode-value "info-look")
139 (declare-function info-lookup-select-mode "info-look")
140 (declare-function info-lookup-change-mode "info-look")
141 (declare-function info-lookup "info-look")
144 (defun counsel-info-lookup-symbol (symbol &optional mode)
145 "Forward to (`info-describe-symbol' SYMBOL MODE) with ivy completion."
149 (let* ((topic 'symbol)
150 (mode (cond (current-prefix-arg
151 (info-lookup-change-mode topic))
152 ((info-lookup->mode-value
153 topic (info-lookup-select-mode))
155 ((info-lookup-change-mode topic))))
156 (completions (info-lookup->completions topic mode))
157 (enable-recursive-minibuffers t)
160 (mapcar #'car completions)
162 (list value info-lookup-mode))))
164 (info-lookup 'symbol symbol mode))
167 (defun counsel-unicode-char ()
168 "Insert a Unicode character at point."
170 (let ((minibuffer-allow-text-properties t))
171 (ivy-read "Unicode name: "
174 (format "% -60s%c" (car x) (cdr x))
177 :action (lambda (char)
178 (insert-char (get-text-property 0 'result char))))))
180 (declare-function cider-sync-request:complete "ext:cider-client")
182 (defun counsel-clj ()
183 "Clojure completion at point."
189 (cider-sync-request:complete str ":same")))))
192 (defun counsel-git ()
193 "Find file in the current Git repository."
195 (let* ((default-directory (locate-dominating-file
196 default-directory ".git"))
198 (shell-command-to-string
199 "git ls-files --full-name --")
202 (action (lambda (x) (find-file x))))
203 (ivy-read "Find file: " cands
206 (defvar counsel--git-grep-dir nil
207 "Store the base git directory.")
209 (defvar counsel--git-grep-count nil
210 "Store the line count in current repository.")
212 (defun counsel-git-grep-function (string &optional _pred &rest _unused)
213 "Grep in the current git repository for STRING."
214 (if (and (> counsel--git-grep-count 20000)
215 (< (length string) 3))
217 (setq ivy--full-length counsel--git-grep-count)
219 (format "%d chars more" (- 3 (length ivy-text)))))
220 (let* ((default-directory counsel--git-grep-dir)
221 (cmd (format "git --no-pager grep --full-name -n --no-color -i -e %S"
222 (ivy--regex string t)))
224 (if (<= counsel--git-grep-count 20000)
226 (setq res (shell-command-to-string cmd))
227 (setq ivy--full-length nil)
228 (split-string res "\n" t))
229 (setq ivy--full-length -1)
230 (counsel--gg-candidates (ivy--regex string))
233 (defvar counsel-git-grep-map
234 (let ((map (make-sparse-keymap)))
235 (define-key map (kbd "C-l") 'counsel-git-grep-recenter)
238 (defun counsel-git-grep-recenter ()
240 (with-selected-window (ivy-state-window ivy-last)
241 (counsel-git-grep-action ivy--current)
242 (recenter-top-bottom)))
244 (defun counsel-git-grep-action (x)
245 (when (string-match "\\`\\(.*?\\):\\([0-9]+\\):\\(.*\\)\\'" x)
246 (let ((file-name (match-string-no-properties 1 x))
247 (line-number (match-string-no-properties 2 x)))
248 (find-file (expand-file-name file-name counsel--git-grep-dir))
249 (goto-char (point-min))
250 (forward-line (1- (string-to-number line-number)))
251 (re-search-forward (ivy--regex ivy-text t) (line-end-position) t)
252 (unless (eq ivy-exit 'done)
253 (setq swiper--window (selected-window))
255 (swiper--add-overlays (ivy--regex ivy-text))))))
258 (defun counsel-git-grep (&optional initial-input)
259 "Grep for a string in the current git repository."
261 (setq counsel--git-grep-dir
262 (locate-dominating-file default-directory ".git"))
263 (if (null counsel--git-grep-dir)
264 (error "Not in a git repository")
265 (setq counsel--git-grep-count (counsel--gg-count "" t))
266 (ivy-read "pattern: " 'counsel-git-grep-function
267 :initial-input initial-input
268 :matcher #'counsel-git-grep-matcher
269 :dynamic-collection (when (> counsel--git-grep-count 20000)
270 'counsel-git-grep-function)
271 :keymap counsel-git-grep-map
272 :action #'counsel-git-grep-action
273 :unwind #'swiper--cleanup)))
275 (defcustom counsel-find-file-at-point nil
276 "When non-nil, add file-at-point to the list of candidates."
280 (declare-function ffap-guesser "ffap")
283 (defun counsel-find-file ()
284 "Forward to `find-file'."
286 (ivy-read "Find file: " 'read-file-name-internal
287 :matcher #'counsel--find-file-matcher
290 (find-file (expand-file-name x ivy--directory)))
291 :preselect (when counsel-find-file-at-point
295 (defcustom counsel-find-file-ignore-regexp nil
296 "A regexp of files to ignore while in `counsel-find-file'.
297 These files are un-ignored if `ivy-text' matches them.
298 The common way to show all files is to start `ivy-text' with a dot.
299 Possible value: \"\\(?:\\`[#.]\\)\\|\\(?:[#~]\\'\\)\"."
302 (defun counsel--find-file-matcher (regexp candidates)
303 "Return REGEXP-matching CANDIDATES.
304 Skip some dotfiles unless `ivy-text' requires them."
305 (let ((res (cl-remove-if-not
307 (string-match regexp x))
309 (if (or (null counsel-find-file-ignore-regexp)
310 (string-match counsel-find-file-ignore-regexp ivy-text))
314 (string-match counsel-find-file-ignore-regexp x))
317 (defun counsel-git-grep-matcher (regexp candidates)
318 (or (and (equal regexp ivy--old-re)
325 (when (string-match "^[^:]+:[^:]+:" x)
326 (setq x (substring x (match-end 0)))
328 (string-match regexp x)
335 (string-match (car re) x)
336 (not (string-match (car re) x)))))))
339 (setq ivy--old-re regexp))))
341 (defun counsel-locate-function (str &rest _u)
342 (if (< (length str) 3)
344 (format "%d chars more" (- 3 (length ivy-text))))
346 (shell-command-to-string (concat "locate -i -l 20 --regex " (ivy--regex str))) "\n" t)))
349 (defun counsel-locate ()
352 (let ((val (ivy-read "pattern: " 'counsel-locate-function)))
356 (defun counsel--generic (completion-fn)
357 "Complete thing at point with COMPLETION-FN."
358 (let* ((bnd (bounds-of-thing-at-point 'symbol))
360 (buffer-substring-no-properties
363 (candidates (funcall completion-fn str))
365 (res (ivy-read (format "pattern (%s): " str)
369 (delete-region (car bnd) (cdr bnd)))
372 (defun counsel-directory-parent (dir)
373 "Return the directory parent of directory DIR."
374 (concat (file-name-nondirectory
375 (directory-file-name dir)) "/"))
377 (defun counsel-string-compose (prefix str)
378 "Make PREFIX the display prefix of STR though text properties."
379 (let ((str (copy-sequence str)))
382 (concat prefix (substring str 0 1))
387 (defun counsel-load-library ()
388 "Load a selected the Emacs Lisp library.
389 The libraries are offered from `load-path'."
391 (let ((dirs load-path)
392 (suffix (concat (regexp-opt '(".el" ".el.gz") t) "\\'"))
393 (cands (make-hash-table :test #'equal))
399 (when (file-directory-p dir)
400 (dolist (file (file-name-all-completions "" dir))
401 (when (string-match suffix file)
402 (unless (string-match "pkg.elc?$" file)
403 (setq short-name (substring file 0 (match-beginning 0)))
404 (if (setq old-val (gethash short-name cands))
406 ;; assume going up directory once will resolve name clash
407 (setq dir-parent (counsel-directory-parent (cdr old-val)))
410 (counsel-string-compose dir-parent (car old-val))
413 (setq dir-parent (counsel-directory-parent dir))
414 (puthash (concat dir-parent short-name)
417 (counsel-string-compose
418 dir-parent short-name)
419 'full-name (expand-file-name file dir))
425 'full-name (expand-file-name file dir))
427 (maphash (lambda (_k v) (push (car v) res)) cands)
428 (ivy-read "Load library: " (nreverse res)
431 (get-text-property 0 'full-name x)))
432 :keymap counsel-describe-map)))
434 (defun counsel--gg-candidates (regex)
435 "Return git grep candidates for REGEX."
436 (counsel--gg-count regex)
437 (let* ((default-directory counsel--git-grep-dir)
438 (counsel-gg-process " *counsel-gg*")
439 (proc (get-process counsel-gg-process))
440 (buff (get-buffer counsel-gg-process)))
442 (delete-process proc))
445 (setq proc (start-process-shell-command
448 (format "git --no-pager grep --full-name -n --no-color -i -e %S | head -n 200"
450 (set-process-sentinel
452 #'counsel--gg-sentinel)))
454 (defun counsel--gg-sentinel (process event)
455 (if (string= event "finished\n")
457 (with-current-buffer (process-buffer process)
458 (setq ivy--all-candidates (split-string (buffer-string) "\n" t))
459 (setq ivy--old-cands ivy--all-candidates))
460 (unless (eq ivy--full-length -1)
461 (ivy--insert-minibuffer
462 (ivy--format ivy--all-candidates))))
463 (if (string= event "exited abnormally with code 1\n")
466 (defun counsel--gg-count (regex &optional no-async)
467 "Quickly and asynchronously count the amount of git grep REGEX matches.
468 When NO-ASYNC is non-nil, do it synchronously."
469 (let ((default-directory counsel--git-grep-dir)
470 (cmd (format "git grep -i -c '%s' | sed 's/.*:\\(.*\\)/\\1/g' | awk '{s+=$1} END {print s}'"
472 (counsel-ggc-process " *counsel-gg-count*"))
474 (string-to-number (shell-command-to-string cmd))
475 (let ((proc (get-process counsel-ggc-process))
476 (buff (get-buffer counsel-ggc-process)))
478 (delete-process proc))
481 (setq proc (start-process-shell-command
485 (set-process-sentinel
487 #'(lambda (process event)
488 (when (string= event "finished\n")
489 (with-current-buffer (process-buffer process)
490 (setq ivy--full-length (string-to-number (buffer-string))))
491 (ivy--insert-minibuffer
492 (ivy--format ivy--all-candidates)))))))))
494 (defun counsel--M-x-transformer (cmd)
495 "Add a binding to CMD if it's bound in the current window.
496 CMD is a command name."
497 (let ((binding (substitute-command-keys (format "\\[%s]" cmd))))
498 (setq binding (replace-regexp-in-string "C-x 6" "<f2>" binding))
499 (if (string-match "^M-x" binding)
501 (format "%s (%s)" cmd
502 (propertize binding 'face 'font-lock-keyword-face)))))
504 (defvar smex-initialized-p)
505 (defvar smex-ido-cache)
506 (declare-function smex-initialize "ext:smex")
507 (declare-function smex-detect-new-commands "ext:smex")
508 (declare-function smex-update "ext:smex")
509 (declare-function smex-rank "ext:smex")
512 (defun counsel-M-x (&optional initial-input)
513 "Ivy version of `execute-extended-command'.
514 Optional INITIAL-INPUT is the initial input in the minibuffer."
516 (unless initial-input
517 (setq initial-input (cdr (assoc this-command
518 ivy-initial-inputs-alist))))
519 (let* ((store ivy-format-function)
524 (with-selected-window (ivy-state-window ivy-last)
525 (mapcar #'counsel--M-x-transformer cands)))))
529 (when (or (featurep 'smex)
530 (package-installed-p 'smex))
532 (unless smex-initialized-p
534 (smex-detect-new-commands)
536 (setq cands smex-ido-cache)
539 (ivy-read "M-x " cands
542 :history 'extended-command-history
545 (when (featurep 'smex)
546 (smex-rank (intern cmd)))
547 (let ((prefix-arg current-prefix-arg))
548 (command-execute (intern cmd) 'record)))
550 :keymap counsel-describe-map
551 :initial-input initial-input)))
553 (declare-function powerline-reset "ext:powerline")
555 (defun counsel--load-theme-action (x)
556 "Disable current themes and load theme X."
559 (mapc #'disable-theme custom-enabled-themes)
560 (load-theme (intern x))
561 (when (fboundp 'powerline-reset)
563 (error "Problem loading theme %s" x)))
566 (defun counsel-load-theme ()
567 "Forward to `load-theme'.
568 Usable with `ivy-resume', `ivy-next-line-and-call' and
569 `ivy-previous-line-and-call'."
571 (ivy-read "Load custom theme: "
573 (custom-available-themes))
574 :action #'counsel--load-theme-action))
579 ;;; counsel.el ends here