Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

file 174 lines (151 sloc) 6.885 kb
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
;;; helm-command.el --- Helm execute-exended-command.

;; Copyright (C) 2012 Thierry Volpiatto <thierry.volpiatto@gmail.com>

;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with this program. If not, see <http://www.gnu.org/licenses/>.

;;; Code:

(require 'cl)
(require 'helm)
(require 'helm-mode)


(defgroup helm-command nil
  "Emacs command related Applications and libraries for Helm."
  :group 'helm)

(defcustom helm-M-x-requires-pattern 2
  "Value of requires-pattern for `helm-M-x'.
Set it to 0 to disable requires-pattern in `helm-M-x'."
  :group 'helm-command
  :type 'boolean)

(defcustom helm-M-x-always-save-history nil
  "`helm-M-x' Save command in `extended-command-history' even when it fail."
  :group 'helm-command
  :type 'boolean)


;;; Faces
;;
;;
(defface helm-M-x-key '((t (:foreground "orange" :underline t)))
  "*Face used in helm-M-x to show keybinding."
  :group 'helm-command)


(defvar helm-M-x-input-history nil)

(defun* helm-M-x-get-major-mode-command-alist (mode-map)
  "Return alist of MODE-MAP."
  (loop for key being the key-seqs of mode-map using (key-bindings com)
        for str-key = (key-description key)
        for ismenu = (string-match "<menu-bar>" str-key)
        unless ismenu collect (cons str-key com)))

(defun helm-get-mode-map-from-mode (mode)
  "Guess the mode-map name according to MODE.
Some modes don't use conventional mode-map name
so we need to guess mode-map name. e.g python-mode ==> py-mode-map.
Return nil if no mode-map found."
  (loop ;; Start with a conventional mode-map name.
        with mode-map = (intern-soft (format "%s-map" mode))
        with mode-string = (symbol-name mode)
        with mode-name = (replace-regexp-in-string "-mode" "" mode-string)
        while (not mode-map)
        for count downfrom (length mode-name)
        ;; Return when no result after parsing entire string.
        when (eq count 0) return nil
        for sub-name = (substring mode-name 0 count)
        do (setq mode-map (intern-soft (format "%s-map" (concat sub-name "-mode"))))
        finally return mode-map))

(defun helm-M-x-current-mode-map-alist ()
  "Return mode-map alist of current `major-mode'."
  (let ((map (helm-get-mode-map-from-mode major-mode)))
    (when (and map (boundp map))
      (helm-M-x-get-major-mode-command-alist (symbol-value map)))))


(defun helm-M-x-transformer (candidates sources)
  "filtered-candidate-transformer to show bindings in emacs commands.
Show global bindings and local bindings according to current `major-mode'."
  (with-helm-current-buffer
    (loop with local-map = (helm-M-x-current-mode-map-alist)
          for cand in candidates
          for local-key = (car (rassq cand local-map))
          for key = (substitute-command-keys (format "\\[%s]" cand))
          collect
          (cons (cond ((and (string-match "^M-x" key) local-key)
                       (format "%s (%s)"
                               cand (propertize
                                     local-key
                                     'face 'helm-M-x-key)))
                      ((string-match "^M-x" key) cand)
                      (t (format "%s (%s)"
                                 cand (propertize
                                       key
                                       'face 'helm-M-x-key))))
                cand) into ls
          finally return
          (sort ls #'(lambda (x y) (string-lessp (car x) (car y)))))))

;;;###autoload
(defun helm-M-x ()
  "Preconfigured `helm' for Emacs commands.
It is `helm' replacement of regular `M-x' `execute-extended-command'."
  (interactive)
  (let* (in-help
         help-cand
         helm-persistent-action-use-special-display
         (history (loop with hist
                        for i in extended-command-history
                        for com = (intern i)
                        when (commandp com)
                        collect i into hist finally return hist))
         command sym-com)
    (flet ((pers-help (candidate)
             (let ((hbuf (get-buffer (help-buffer)))
                   special-display-buffer-names
                   special-display-regexps)
               (if (and in-help (string= candidate help-cand))
                   (progn
                     ;; When M-x is started from a help buffer,
                     ;; Don't kill it as it is helm-current-buffer.
                     (unless (equal hbuf helm-current-buffer)
                       (kill-buffer hbuf)
                       (set-window-buffer (get-buffer-window hbuf)
                                          helm-current-buffer))
                     (setq in-help nil))
                   ;; Be sure helm-current-buffer
                   ;; have not a dedicated window.
                   (set-window-dedicated-p
                    (get-buffer-window helm-current-buffer) nil)
                   (describe-function (intern candidate))
                   (message nil) ; Erase the new stupid message Type "q"[...]
                   (setq in-help t))
               (setq help-cand candidate))))
      (setq command (helm-comp-read
                     "M-x " obarray
                     :test 'commandp
                     :requires-pattern helm-M-x-requires-pattern
                     :name "Emacs Commands"
                     :buffer "*helm M-x*"
                     :persistent-action 'pers-help
                     :persistent-help "Describe this command"
                     :history history
                     :del-input nil
                     :must-match t
                     :candidates-in-buffer t
                     :fc-transformer 'helm-M-x-transformer))
      (setq sym-com (intern command))
      (unless current-prefix-arg
        (setq current-prefix-arg helm-current-prefix-arg))
      ;; Avoid having `this-command' set to *exit-minibuffer.
      (setq this-command sym-com)
      (unless helm-M-x-always-save-history
        (call-interactively sym-com))
      (setq extended-command-history
            (cons command (delete command history)))
      (when helm-M-x-always-save-history
        (call-interactively sym-com)))))

(provide 'helm-command)

;; Local Variables:
;; byte-compile-warnings: (not cl-functions obsolete)
;; coding: utf-8
;; indent-tabs-mode: nil
;; byte-compile-dynamic: t
;; End:

;;; helm-command.el ends here
Something went wrong with that request. Please try again.