ido-ubiquitous.el 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624
  1. ;;; ido-ubiquitous.el --- Use ido (nearly) everywhere.
  2. ;; Author: Ryan C. Thompson
  3. ;; URL: https://github.com/DarwinAwardWinner/ido-ubiquitous
  4. ;; Version: 2.0
  5. ;; Created: 2011-09-01
  6. ;; Keywords: convenience
  7. ;; EmacsWiki: InteractivelyDoThings
  8. ;; This file is NOT part of GNU Emacs.
  9. ;;; Commentary:
  10. ;; If you use the excellent `ido-mode' for efficient completion of
  11. ;; file names and buffers, you might wonder if you can get ido-style
  12. ;; completion everywhere else too. Well, that's what this package
  13. ;; does! ido-ubiquitous is here to enable ido-style completion for
  14. ;; (almost) every function that uses the standard completion function
  15. ;; `completing-read'.
  16. ;;; License:
  17. ;; This program is free software; you can redistribute it and/or modify
  18. ;; it under the terms of the GNU General Public License as published by
  19. ;; the Free Software Foundation; either version 3, or (at your option)
  20. ;; any later version.
  21. ;;
  22. ;; This program is distributed in the hope that it will be useful,
  23. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  24. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  25. ;; GNU General Public License for more details.
  26. ;;
  27. ;; You should have received a copy of the GNU General Public License
  28. ;; along with GNU Emacs; see the file COPYING. If not, write to the
  29. ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  30. ;; Boston, MA 02110-1301, USA.
  31. ;;; Code:
  32. (eval-when-compile
  33. (when (or (not (boundp 'completing-read-function))
  34. (< emacs-major-version 24))
  35. (error "Could not find required variable `completing-read-function'. Are you using Emacs version 24 or higher? If you have Emacs 23 or lower, please downgrade to ido-ubiquitous version 1.7.")))
  36. (require 'ido)
  37. (require 'advice)
  38. (require 'cl)
  39. ;;; Internal utility functions
  40. (defun ido-ubiquitous--as-string (sym-or-str)
  41. "Return name of symbol, return string as is."
  42. (if (symbolp sym-or-str)
  43. (symbol-name sym-or-str)
  44. sym-or-str))
  45. (defun ido-ubiquitous--as-symbol (sym-or-str)
  46. "Return name of symbol, return string as is."
  47. (if (symbolp sym-or-str)
  48. sym-or-str
  49. (intern sym-or-str)))
  50. ;;; Custom widget definitions
  51. ;; We need to define some custom widget types for use in the override
  52. ;; variables.
  53. (define-widget 'lazy-notag 'lazy
  54. "Like lazy widget, but does not display its tag, only its value."
  55. :format "%v")
  56. ;; Define matcher functions and widgets for match specifications
  57. (defvar ido-ubiquitous-match-spec-widget-types nil
  58. "List of widget names for match specs.")
  59. (defvar ido-ubiquitous-spec-matchers nil
  60. "Alist of functions for matching function specs against function names.")
  61. (loop for (widget-name widget-tag key field-type matcher) in
  62. '((exact-match "Exact match" exact string string=)
  63. (prefix-match "Prefix match" prefix string string-prefix-p)
  64. (regexp-match "Regexp match" regexp regexp string-match-p))
  65. do (define-widget (ido-ubiquitous--as-symbol widget-name) 'lazy-notag widget-tag
  66. :menu-tag widget-tag
  67. :type `(list :tag ,widget-tag :format "%v"
  68. (const :format ""
  69. :tag ,widget-tag
  70. ,key)
  71. (,field-type :tag ,widget-tag)))
  72. do (add-to-list 'ido-ubiquitous-match-spec-widget-types
  73. widget-name 'append)
  74. do (add-to-list 'ido-ubiquitous-spec-matchers
  75. (cons key matcher) 'append))
  76. (define-widget 'ido-ubiquitous-match-spec 'lazy-notag
  77. "Choice of exact, prefix, or regexp match."
  78. :type `(choice :tag "Match type"
  79. ,@ido-ubiquitous-match-spec-widget-types))
  80. (define-widget 'ido-ubiquitous-command-override-spec 'lazy-notag
  81. "Choice of override action plus match specification."
  82. :type '(cons :tag "Override rule"
  83. (choice :tag "For matching commands"
  84. (const :menu-tag "Disable"
  85. :tag "Disable ido-ubiquitous"
  86. disable)
  87. (const :menu-tag "Enable"
  88. :tag "Enable ido-ubiquitous in normal default mode"
  89. enable)
  90. (const :menu-tag "Enable old-style default"
  91. :tag "Enable ido-ubiquitous in old-style default mode"
  92. enable-old))
  93. ido-ubiquitous-match-spec))
  94. (define-widget 'ido-ubiquitous-function-override-spec 'lazy-notag
  95. "Choice of override action and function name. (Exact match only.)"
  96. :type '(list :tag "Override rule"
  97. (choice :tag "Do the following"
  98. (const :menu-tag "Disable"
  99. :tag "Disable ido-ubiquitous"
  100. disable)
  101. (const :menu-tag "Enable"
  102. :tag "Enable ido-ubiquitous in normal default mode"
  103. enable)
  104. (const :menu-tag "Enable old-style default"
  105. :tag "Enable ido-ubiquitous in old-style default mode"
  106. enable-old))
  107. (const :format "" exact)
  108. (string :tag "For function")))
  109. ;;; Custom Declarations
  110. ;;;###autoload
  111. (defgroup ido-ubiquitous nil
  112. "Use ido for (almost) all completion."
  113. :group 'ido)
  114. ;;;###autoload
  115. (define-minor-mode ido-ubiquitous-mode
  116. "Use `ido-completing-read' instead of `completing-read' almost everywhere.
  117. This mode has no effect unles `ido-mode' is also enabled.
  118. If this mode causes problems for a function, you can customize
  119. when ido completion is or is not used by customizing
  120. `ido-ubiquitous-command-overrides' or
  121. `ido-ubiquitous-function-overrides'."
  122. nil
  123. :global t
  124. :group 'ido-ubiquitous
  125. ;; Handle warning about ido disabled
  126. (when ido-ubiquitous-mode
  127. (ido-ubiquitous-warn-about-ido-disabled))
  128. ;; Ensure emacs 23 code disabled (in case user upgraded in this session)
  129. (ignore-errors
  130. (ad-disable-advice 'completing-read 'around 'ido-ubiquitous-legacy)
  131. (ad-activate 'completing-read))
  132. ;; Actually enable/disable the mode
  133. (setq completing-read-function
  134. (if ido-ubiquitous-mode
  135. 'completing-read-ido
  136. ido-ubiquitous-fallback-completing-read-function)))
  137. ;;;###autoload
  138. (defcustom ido-ubiquitous-fallback-completing-read-function
  139. ;; Initialize to the current value of `completing-read-function',
  140. ;; unless that is already set to the ido completer, in which case
  141. ;; use `completing-read-default'.
  142. (if (eq completing-read-function 'completing-read-ido)
  143. 'completing-read-default
  144. completing-read-function)
  145. "Alternate completing-read function to use when ido is not wanted.
  146. This will be used for functions that are incompatibile with ido
  147. or if ido cannot handle the completion arguments.
  148. If you turn off ido-ubiquitous mode, `completing-read-function'
  149. will be set back to this."
  150. :type '(choice (const :tag "Standard emacs completion"
  151. completing-read-default)
  152. (function :tag "Other function"))
  153. :group 'ido-ubiquitous)
  154. ;;;###autoload
  155. (defcustom ido-ubiquitous-enable-old-style-default t
  156. "Allow ido to emulate a quirk of `completing-read'.
  157. From the `completing-read' docstring:
  158. > If the input is null, `completing-read' returns DEF, or the
  159. > first element of the list of default values, or an empty string
  160. > if DEF is nil, regardless of the value of REQUIRE-MATCH.
  161. If this variable is non-nil, then ido-ubiquitous will attempt to
  162. emulate this behavior. Specifically, if RET is pressed
  163. immediately upon entering completion, an empty string will be
  164. returned instead of the first element in the list. This behavior
  165. is only enabled when ido is being used as a substitute for
  166. `completing-read', and not when it is used directly.
  167. This odd behavior is required for compatibility with an old-style
  168. usage pattern whereby the default was requested by returning an
  169. empty string. In this mode, the caller receives the empty string
  170. and handles the default case manually, while `completing-read'
  171. never has any knowledge of the default. This is a problem for
  172. ido, which always returns the first element in the list when the
  173. input is empty. Without knowledge of the default, it cannot
  174. ensure that the default is first on the list, so returning the
  175. first item is not the correct behavior. Instead, it must return
  176. an empty string like `completing-read'.
  177. You can termporarily invert this behavior by prefixing \"RET\"
  178. with \"C-u\".
  179. If you want to enable old-style default selection selectively for
  180. specific commands or functions, set appropriate overrides in
  181. `ido-ubiquitous-command-overrides' or
  182. `ido-ubiquitous-function-overrides'."
  183. :type 'boolean
  184. :group 'ido-ubiquitous)
  185. (defconst ido-ubiquitous-default-command-overrides
  186. '(;; If you want ido for M-x, install smex
  187. (disable exact "execute-extended-command")
  188. ;; https://github.com/technomancy/ido-ubiquitous/issues/13#issuecomment-8033522
  189. (enable prefix "wl-")
  190. ;; https://github.com/technomancy/ido-ubiquitous/issues/7
  191. (enable-old prefix "Info-")
  192. ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/4
  193. (enable exact "webjump"))
  194. "Default value of `ido-ubiquitous-command-overrides'.
  195. You can restore these using the command `ido-ubiquitous-restore-default-overrides'.")
  196. (defconst ido-ubiquitous-default-function-overrides
  197. '((disable exact "read-file-name")
  198. (disable exact "read-file-name-internal")
  199. (disable exact "read-buffer")
  200. (disable exact "gnus-emacs-completing-read")
  201. (disable exact "gnus-iswitchb-completing-read")
  202. (disable exact "man")
  203. ;; https://github.com/technomancy/ido-ubiquitous/issues/3
  204. (disable exact "grep-read-files")
  205. ;; https://github.com/technomancy/ido-ubiquitous/issues/9
  206. (enable exact "bookmark-completing-read")
  207. ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/4
  208. (enable-old exact "webjump-read-choice")
  209. (enable-old exact "webjump-read-url-choice"))
  210. "Default value of `ido-ubiquitous-function-overrides'.
  211. You can restore these using the command `ido-ubiquitous-restore-default-overrides'.")
  212. ;;;###autoload
  213. (defcustom ido-ubiquitous-command-overrides ido-ubiquitous-default-command-overrides
  214. "List of command override specifications for ido-ubiquitous
  215. Each override specification describes how ido-ubiquitous should
  216. behave one or many commands. A specification has the
  217. form `(BEHAVIOR MATCH-TYPE MATCH-TEXT)'. BEHAVIOR is one of the
  218. following:
  219. * `disable': ido-ubiquitous should not be used at all for the
  220. specified commands;
  221. * `enable': ido-ubiquitous may be used with the specified
  222. commands, without emulating the old-style default selection
  223. of `completing-read';
  224. * `enable-old': ido-ubiquitous may be used with the specified
  225. commands, and should emulate the old-style default selection
  226. of `completing-read'.
  227. MATCH-TYPE affects how MATCH-TEXT is interpreted, as follows:
  228. * `exact': the specification only affects the one command
  229. whose name is MATCH-TEXT;
  230. * `prefix': the specification affects any command whose name
  231. starts with MATCH-TEXT (This is useful for specifying a
  232. certain behavior for an entire package);
  233. * `regexp': the specification affects any command whose name
  234. matches MATCH-TEXT (with MATCH-TEXT being interpreted as a
  235. regular expression)
  236. MATCH-TEXT should be a string.
  237. Since this variable's has a somewhat complex structure, it is
  238. recommended that you set this variable through Customize.
  239. Note that this variable only affects *commands*, which are
  240. functions marked as interactive. See
  241. `ido-ubiquitous-function-overrides' for how to modify the
  242. behavior of ido-ubiquitous for arbitrary functions.
  243. If you need to add a new specification to this list, please also
  244. file a bug report at https://github.com/DarwinAwardWinner/ido-ubiquitous/issues"
  245. :type '(repeat ido-ubiquitous-command-override-spec)
  246. :group 'ido-ubiquitous)
  247. (defun ido-ubiquitous-set-function-overrides (sym newval)
  248. "Custom setter function for `ido-ubiquitous-function-overrides'.
  249. In addition to setting the variable, this also sets up advice on
  250. each function to apply the appropriate override."
  251. ;; Unset all previous overrides
  252. (when (boundp sym)
  253. (let ((oldval (eval sym)))
  254. (loop for (action match-type func) in oldval
  255. do (ido-ubiquitous-apply-function-override func nil))))
  256. ;; Ensure that function names are strings, not symbols
  257. (setq newval
  258. (loop for (action match-type func) in newval
  259. collect (list action match-type
  260. (ido-ubiquitous--as-string func))))
  261. (set-default sym newval)
  262. ;; set new overrides
  263. (loop for (action match-type func) in (eval sym)
  264. do (ido-ubiquitous-apply-function-override func action)))
  265. (defun ido-ubiquitous-apply-function-override (func override)
  266. "Set the override property on FUNC to OVERRIDE and set up advice to apply the override."
  267. (setq func (ido-ubiquitous--as-symbol func)
  268. override (ido-ubiquitous--as-symbol override))
  269. (put func 'ido-ubiquitous-override override)
  270. (when override
  271. (let ((docstring
  272. (format "Override ido-ubiquitous behavior in %s if its `ido-ubiquitous-override' property is non-nil." func)))
  273. (eval
  274. `(defadvice ,func (around ido-ubiquitous-override activate)
  275. ,docstring
  276. (ido-ubiquitous-with-override
  277. (get ',func 'ido-ubiquitous-override)
  278. ad-do-it))))))
  279. ;;;###autoload
  280. (defcustom ido-ubiquitous-function-overrides ido-ubiquitous-default-function-overrides
  281. "List of function override specifications for ido-ubiquitous
  282. Function override specifications have a similar structure to
  283. command override specifications (see
  284. `ido-ubiquitous-command-overrides'). A function override
  285. specification has the form `(BEHAVIOR MATCH-TYPE MATCH-TEXT)'.
  286. However, `MATCH-TYPE' may ONLY be `exact'; No other match type is
  287. supported.
  288. If you need to add a new specification to this list, please also file a
  289. bug report at https://github.com/DarwinAwardWinner/ido-ubiquitous/issues
  290. Setting this variable directly has no effect. You must set it
  291. through Customize."
  292. :type '(repeat ido-ubiquitous-function-override-spec)
  293. :set 'ido-ubiquitous-set-function-overrides
  294. :group 'ido-ubiquitous)
  295. ;;; ido-ubiquitous core
  296. (defvar ido-ubiquitous-next-call-replaces-completing-read nil
  297. "If t, then the next call to `ido-completing-read' is by ido-ubiquitous.")
  298. (defvar ido-ubiquitous-this-call-replaces-completing-read nil
  299. "If t, then the current call to `ido-completing-read' is by ido-ubiquitous.")
  300. (defvar ido-ubiquitous-next-override nil
  301. "This holds the override to be applied on the next call to `completing-read'.")
  302. (defvar ido-ubiquitous-active-override nil
  303. "This holds the override being applied to the current call to `completing-read'.")
  304. (defun ido-ubiquitous-completing-read (&rest args)
  305. "Wrapper for `ido-completing-read' that enables ido-ubiquitous features."
  306. (let ((ido-ubiquitous-next-call-replaces-completing-read t))
  307. (apply 'ido-completing-read args)))
  308. (defadvice ido-completing-read (around detect-replacing-cr activate)
  309. "Enable workarounds if this call was done through ido-ubiquitous.
  310. This advice implements the logic required for
  311. `ido-completing-read' to handle a number of special cases that
  312. `completing-read' can handle. It only has an effect if
  313. `ido-completing-read' is called through
  314. `ido-ubiquitous-completing-read', so other packages that use
  315. `ido-completing-read', such as `smex', will not be affected."
  316. (let* ((ido-ubiquitous-this-call-replaces-completing-read ido-ubiquitous-next-call-replaces-completing-read)
  317. (ido-ubiquitous-next-call-replaces-completing-read nil))
  318. (when ido-ubiquitous-this-call-replaces-completing-read
  319. ;; ido doesn't natively handle DEF being a list. If DEF is a
  320. ;; list, prepend it to CHOICES and set DEF to just the car of
  321. ;; the default list.
  322. (when (and def (listp def))
  323. (setq choices (delete-dups (append def choices))
  324. def (car def)))
  325. ;; Work around a bug in ido when both INITIAL-INPUT and DEF are provided
  326. ;; More info: https://github.com/technomancy/ido-ubiquitous/issues/18
  327. (let ((initial (cond ((null initial-input) "")
  328. ((stringp initial-input) initial-input)
  329. ((consp initial-input) (car initial-input))
  330. (t initial-input)))
  331. (deflist (if (listp def)
  332. def
  333. (list def))))
  334. (when (and deflist initial
  335. (stringp initial)
  336. (not (string= initial "")))
  337. ;; Both default and initial input were provided. So keep the
  338. ;; initial input and preprocess the choices list to put the
  339. ;; default at the head, then proceed with default = nil.
  340. (setq choices (delete-dups (append deflist choices))
  341. def nil))))
  342. ad-do-it))
  343. (defun completing-read-ido (prompt collection &optional predicate
  344. require-match initial-input
  345. hist def inherit-input-method)
  346. "ido-based method for reading from the minibuffer with completion.
  347. See `completing-read' for the meaning of the arguments.
  348. This function is a wrapper for `ido-completing-read' designed to
  349. be used as the value of `completing-read-function'. Importantly,
  350. it detects edge cases that ido cannot handle and uses normal
  351. completion for them."
  352. (let* (;; Set the active override and clear the "next" one so it
  353. ;; doesn't apply to nested calls.
  354. (ido-ubiquitous-active-override ido-ubiquitous-next-override)
  355. (ido-ubiquitous-next-override nil)
  356. ;; Pre-expand list of possible completions
  357. (collection
  358. (all-completions "" collection predicate))
  359. ;; Don't need this any more
  360. (predicate nil)
  361. ;; Check for conditions that ido can't or shouldn't handle
  362. (ido-allowed
  363. (and ido-mode
  364. ido-ubiquitous-mode
  365. ;; Don't use ido if there are no completions.
  366. collection
  367. ;; Check for disable override
  368. (not (eq ido-ubiquitous-active-override 'disable))
  369. ;; Can't handle this arg
  370. (not inherit-input-method)
  371. ;; Can't handle this being set
  372. (not (bound-and-true-p completion-extra-properties))))
  373. (comp-read-fun
  374. (if ido-allowed
  375. 'ido-ubiquitous-completing-read
  376. ido-ubiquitous-fallback-completing-read-function)))
  377. (funcall comp-read-fun
  378. prompt collection predicate
  379. require-match initial-input
  380. hist def inherit-input-method)))
  381. ;;; Old-style default support
  382. (defvar ido-ubiquitous-initial-item nil
  383. "The first item selected when ido starts.
  384. This is initialized to the first item in the list of completions
  385. when ido starts, and is cleared when any character is entered
  386. into the prompt or the list is cycled. If it is non-nil and still
  387. equal to the first item in the completion list when ido exits,
  388. then if `ido-ubiquitous-enable-old-style-default' is
  389. non-nil, ido returns an empty string instead of the first item on
  390. the list.")
  391. (defadvice ido-read-internal (before clear-initial-item activate)
  392. (setq ido-ubiquitous-initial-item nil))
  393. (defadvice ido-make-choice-list (after set-initial-item activate)
  394. (when (and ad-return-value (listp ad-return-value))
  395. (setq ido-ubiquitous-initial-item (car ad-return-value))))
  396. (defadvice ido-next-match (after clear-initial-item activate)
  397. (setq ido-ubiquitous-initial-item nil))
  398. (defadvice ido-prev-match (after clear-initial-item activate)
  399. (setq ido-ubiquitous-initial-item nil))
  400. (defadvice ido-exit-minibuffer (around compatibility activate)
  401. "Emulate a quirk of `completing-read'.
  402. > If the input is null, `completing-read' returns DEF, or the
  403. > first element of the list of default values, or an empty string
  404. > if DEF is nil, regardless of the value of REQUIRE-MATCH.
  405. See `ido-ubiquitous-enable-old-style-default', which
  406. controls whether this advice has any effect."
  407. (not current-prefix-arg)
  408. (let* ((enable-oldstyle
  409. (and
  410. ;; Completing a list, not a buffer or file
  411. (eq ido-cur-item 'list)
  412. ;; Only enable if we are replacing `completing-read'
  413. ido-ubiquitous-this-call-replaces-completing-read
  414. ;; Default is nil
  415. (null ido-default-item)
  416. ;; Input is empty
  417. (string= ido-text "")
  418. ;; Old-style default enabled
  419. (if ido-ubiquitous-active-override
  420. (eq ido-ubiquitous-active-override 'enable-old)
  421. ido-ubiquitous-enable-old-style-default)
  422. ;; First item on the list hasn't changed
  423. (string= (car ido-cur-list)
  424. ido-ubiquitous-initial-item)))
  425. ;; Prefix inverts oldstyle behavior
  426. (should-invert current-prefix-arg)
  427. (actually-enable-oldstyle
  428. (if should-invert (not enable-oldstyle) enable-oldstyle)))
  429. (if actually-enable-oldstyle
  430. (ido-select-text)
  431. ad-do-it))
  432. (setq ido-ubiquitous-initial-item nil))
  433. ;;; Overrides
  434. (defun ido-ubiquitous-restore-default-overrides (&optional save)
  435. "Re-add the default overrides for ido-ubiquitous.
  436. This will ensure that the default overrides are all present and
  437. at the head of the list in `ido-ubiquitous-command-overrides' and
  438. `ido-ubiquitous-function-overrides'. User-added overrides will
  439. not be removed, but they may be masked if one of the default
  440. overrides affects the same functions.
  441. With a prefix arg, also save the above variables' new values for
  442. future sessions."
  443. (interactive "P")
  444. (let ((setter (if save
  445. 'customize-save-variable
  446. 'customize-set-variable)))
  447. (loop for ((var def) in '((ido-ubiquitous-command-overrides
  448. ido-ubiquitous-default-command-overrides)
  449. (ido-ubiquitous-function-overrides
  450. ido-ubiquitous-default-function-overrides)))
  451. do (let* ((curval (eval var))
  452. (defval (eval def))
  453. (newval (delete-dups (append defval curval))))
  454. (funcall setter var newval)))
  455. (message (if save
  456. "ido-ubiquitous: Restored default command and function overrides and saved for future sessions."
  457. "ido-ubiquitous: Restored default command and function overrides for current session only."))))
  458. (defmacro ido-ubiquitous-with-override (override &rest body)
  459. "Eval BODY with specicified OVERRIDE in place.
  460. The OVERRIDE argument is evaluated normally, so if it is a
  461. literal symbol, it must be quoted.
  462. See `ido-ubiquitous-command-overrides' for valid override types."
  463. ;; Eval override
  464. (setq override (eval override))
  465. `(let ((ido-ubiquitous-next-override ',override))
  466. ,@body))
  467. ;; (append
  468. ;; (case override
  469. ;; (disable
  470. ;; '(let ((ido-ubiquitous-disable-for-one-command t))))
  471. ;; (enable
  472. ;; '(let ((ido-ubiquitous-newstyle-default-for-one-command t))))
  473. ;; (enable-old
  474. ;; '(let ((ido-ubiquitous-oldstyle-default-for-one-command t))))
  475. ;; ;; No override
  476. ;; (t '(progn)))
  477. ;; body))
  478. (put 'ido-ubiquitous-with-override 'lisp-indent-function
  479. (eval-when-compile (get 'prog1 'lisp-indent-function)))
  480. (defun ido-ubiquitous-spec-match (spec symbol)
  481. "Returns t if SPEC matches SYMBOL (which should be a function name).
  482. See `ido-ubiquitous-command-overrides'."
  483. (destructuring-bind (type text) spec
  484. (let ((matcher (cdr (assoc type ido-ubiquitous-spec-matchers)))
  485. (text (ido-ubiquitous--as-string text))
  486. (symname (ido-ubiquitous--as-string symbol)))
  487. (when (null matcher)
  488. (error "ido-ubiquitous: Unknown match spec type \"%s\". See `ido-ubiquitous-spec-matchers' for valid types." type))
  489. (funcall matcher text symname))))
  490. (defun ido-ubiquitous-get-command-override (cmd)
  491. "Return the override associated with the command CMD.
  492. If there is no override set for CMD in
  493. `ido-ubiquitous-command-overrides', return nil."
  494. (loop for (action . spec) in ido-ubiquitous-command-overrides
  495. when (memq action '(disable enable enable-old nil))
  496. when (ido-ubiquitous-spec-match spec cmd)
  497. return action
  498. finally return nil))
  499. (defadvice call-interactively (around ido-ubiquitous activate)
  500. "Implements the behavior specified in `ido-ubiquitous-command-overrides'."
  501. (ido-ubiquitous-with-override
  502. (ido-ubiquitous-get-command-override function)
  503. ad-do-it))
  504. (defadvice command-execute (around ido-ubiquitous activate)
  505. "Implements the behavior specified in `ido-ubiquitous-command-overrides'."
  506. (ido-ubiquitous-with-override
  507. (ido-ubiquitous-get-command-override cmd)
  508. ad-do-it))
  509. ;;; Other
  510. (defun ido-ubiquitous-warn-about-ido-disabled ()
  511. "Warn if ido-ubiquitous is enabled without ido.
  512. Don't warn if emacs is still initializing, since ido-ubiquitous
  513. could be enabled first during init."
  514. (when (and ido-ubiquitous-mode
  515. after-init-time
  516. (not (bound-and-true-p ido-mode)))
  517. (warn "ido-ubiquitous-mode enabled without ido mode. ido-ubiquitous requires ido mode to be enabled.")))
  518. (defun ido-ubiquitous-initialize ()
  519. "Do initial setup for ido-ubiquitous.
  520. This only needs to be called once when the file is first loaded."
  521. ;; Clean up old versions of ido-ubiquitous that defined advice on
  522. ;; `completing-read' instead of modifying
  523. ;; `completing-read-function'.
  524. (when (ad-find-advice 'completing-read 'around 'ido-ubiquitous)
  525. (ad-remove-advice 'completing-read 'around 'ido-ubiquitous)
  526. (ad-activate 'completing-read))
  527. ;; Make sure the mode is turned on/off as specified by the value of
  528. ;; the mode variable
  529. (ido-ubiquitous-mode (if ido-ubiquitous-mode 1 0)))
  530. (ido-ubiquitous-initialize)
  531. (provide 'ido-ubiquitous) ;;; ido-ubiquitous.el ends here