ido-ubiquitous.el 26 KB

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