ido-ubiquitous-3.14/0000755000175000017500000000000012731324552014261 5ustar dogslegdogslegido-ubiquitous-3.14/ido-ubiquitous.el0000644000175000017500000014561412731324552017600 0ustar dogslegdogsleg;;; ido-ubiquitous.el --- Use ido (nearly) everywhere. -*- lexical-binding: t -*- ;; Copyright (C) 2011-2015 Ryan C. Thompson ;; Author: Ryan C. Thompson ;; URL: https://github.com/DarwinAwardWinner/ido-ubiquitous ;; Version: 3.14 ;; Created: 2011-09-01 ;; Keywords: convenience, completion, ido ;; EmacsWiki: InteractivelyDoThings ;; Package-Requires: ((emacs "24.1") (ido-completing-read+ "3.14") (cl-lib "0.5")) ;; Filename: ido-ubiquitous.el ;; This file is NOT part of GNU Emacs. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Commentary: ;; If you use the excellent `ido-mode' for efficient completion of ;; file names and buffers, you might wonder if you can get ido-style ;; completion everywhere else too. Well, that's what this package ;; does! ido-ubiquitous is here to enable ido-style completion for ;; (almost) every function that uses the standard completion function ;; `completing-read'. ;; To use this package, call `ido-ubiquitous-mode' to enable the mode, ;; or use `M-x customize-variable ido-ubiquitous-mode' it to enable it ;; permanently. Once the mode is enabled, most functions that use ;; `completing-read' will now have ido completion. If you decide in ;; the middle of a command that you would rather not use ido, just C-f ;; or C-b at the end/beginning of the input to fall back to non-ido ;; completion (this is the same shortcut as when using ido for buffers ;; or files). ;; Note that `completing-read' has some quirks and complex behavior ;; that ido cannot emulate. Ido-ubiquitous attempts to detect some of ;; these quirks and avoid using ido when it sees them. So some ;; functions will not have ido completion even when this mode is ;; enabled. Some other functions have ido disabled in them because ;; their packages already provide support for ido via other means (for ;; example, magit). See `M-x customize-group ido-ubiquitous' and read ;; about the override variables for more information. ;; ido-ubiquitous version 3.0 is a major update, including a split ;; into two packages, and some of the configuration options have ;; changed in non-backwards-compatible ways. If you have customized ;; ido-ubiquitous, be sure to check out `M-x customize-group ;; ido-ubiquitous' and `M-x customize-group ido-completing-read+' ;; after updating to 3.0 and make sure the new settings are to your ;; liking. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; 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 GNU Emacs. If not, see . ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Code: (defconst ido-ubiquitous-version "3.14" "Currently running version of ido-ubiquitous. Note that when you update ido-ubiquitous, this variable may not be updated until you restart Emacs.") (eval-when-compile (when (or (not (boundp 'completing-read-function)) (< emacs-major-version 24)) (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 (or upgrade Emacs)."))) (require 'ido) (require 'advice) (require 'cl-lib) (require 'cus-edit) (require 'ido-completing-read+) ;; Only exists in emacs 24.4 and up; we don't use this library ;; directly, but we load it here so we can test if it's available, ;; because if it isn't we need enable a workaround. (require 'nadvice nil 'noerror) ;;; Debug messages ;;;###autoload (define-minor-mode ido-ubiquitous-debug-mode "If non-nil, ido-ubiquitous will print debug info. Debug info is printed to the *Messages* buffer." nil :global t :group 'ido-ubiquitous) ;; Defined as a macro for efficiency (args are not evaluated unless ;; debug mode is on) (defmacro ido-ubiquitous--debug-message (format-string &rest args) `(when ido-ubiquitous-debug-mode (message (concat "ido-ubiquitous: " ,format-string) ,@args))) (defun ido-ubiquitous--explain-fallback (arg) ;; This function accepts a string, or an ido-ubiquitous-fallback ;; signal. (when ido-ubiquitous-debug-mode (when (and (listp arg) (eq (car arg) 'ido-ubiquitous-fallback)) (setq arg (cdr arg))) (ido-ubiquitous--debug-message "Falling back to `%s' because %s." ido-cr+-fallback-function arg))) ;;; Internal utility functions (defun ido-ubiquitous--as-string (sym-or-str) "Return name of symbol, return string as is." (if (symbolp sym-or-str) (symbol-name sym-or-str) sym-or-str)) (defun ido-ubiquitous--as-symbol (sym-or-str) "Return string as symbol, return symbol as is." (if (symbolp sym-or-str) sym-or-str (intern sym-or-str))) ;;; Custom widget definitions ;; We need to define some custom widget types for use in the override ;; variables. (define-widget 'lazy-notag 'lazy "Like lazy widget, but does not display its tag, only its value." :format "%v") ;; Define matcher functions and widgets for match specifications (defvar ido-ubiquitous-match-spec-widget-types nil "List of widget names for match specs.") (defvar ido-ubiquitous-spec-matchers nil "Alist of functions for matching function specs against function names.") (cl-loop for (widget-name widget-tag key field-type matcher) in '((exact-match "Exact match" exact string string=) (prefix-match "Prefix match" prefix string string-prefix-p) (regexp-match "Regexp match" regexp regexp string-match-p)) do (define-widget (ido-ubiquitous--as-symbol widget-name) 'lazy-notag widget-tag :menu-tag widget-tag :type `(list :tag ,widget-tag :format "%v" (const :format "" :tag ,widget-tag ,key) (,field-type :tag ,widget-tag))) do (add-to-list 'ido-ubiquitous-match-spec-widget-types widget-name 'append) do (add-to-list 'ido-ubiquitous-spec-matchers (cons key matcher) 'append)) (define-widget 'ido-ubiquitous-match-spec 'lazy-notag "Choice of exact, prefix, or regexp match." :type `(choice :tag "Match type" ,@ido-ubiquitous-match-spec-widget-types)) (define-widget 'ido-ubiquitous-command-override-spec 'lazy-notag "Choice of override action plus match specification." :type '(cons :tag "Override rule" (choice :tag "For matching commands" (const :menu-tag "Disable" :tag "Disable ido-ubiquitous" disable) (const :menu-tag "Enable" :tag "Enable ido-ubiquitous in normal default mode" enable) (const :menu-tag "Enable old-style default" :tag "Enable ido-ubiquitous in old-style default mode" enable-old)) ido-ubiquitous-match-spec)) (define-widget 'ido-ubiquitous-function-override-spec 'lazy-notag "Choice of override action and function name. (Exact match only.)" :type '(list :tag "Override rule" (choice :tag "Do the following" (const :menu-tag "Disable" :tag "Disable ido-ubiquitous" disable) (const :menu-tag "Enable" :tag "Enable ido-ubiquitous in normal default mode" enable) (const :menu-tag "Enable old-style default" :tag "Enable ido-ubiquitous in old-style default mode" enable-old)) (const :format "" exact) (string :tag "For function"))) ;;; Custom Declarations (defgroup ido-ubiquitous nil "Use ido for (almost) all completion." :group 'ido :group 'ido-completing-read-plus) ;;;###autoload (define-obsolete-variable-alias 'ido-ubiquitous 'ido-ubiquitous-mode "ido-ubiquitous 0.8") ;;;###autoload (define-obsolete-function-alias 'ido-ubiquitous 'ido-ubiquitous-mode "ido-ubiquitous 0.8") ;;;###autoload (define-minor-mode ido-ubiquitous-mode "Use `ido-completing-read' instead of `completing-read' almost everywhere. If this mode causes problems for a function, you can customize when ido completion is or is not used by customizing `ido-ubiquitous-command-overrides' or `ido-ubiquitous-function-overrides'." nil :global t :group 'ido-ubiquitous ;; Actually enable/disable the mode by setting ;; `completing-read-function'. (setq completing-read-function (if ido-ubiquitous-mode #'completing-read-ido-ubiquitous ido-cr+-fallback-function))) ;; Variables for functionality that has moved to ido-completing-read+ (define-obsolete-variable-alias 'ido-ubiquitous-max-items 'ido-cr+-max-items "ido-ubiquitous 3.0") (define-obsolete-variable-alias 'ido-ubiquitous-fallback-completing-read-function 'ido-cr+-fallback-function "ido-ubiquitous 3.0") (define-obsolete-variable-alias 'ido-ubiquitous-enable-compatibility-globally 'ido-ubiquitous-enable-old-style-default "ido-ubiquitous 2.0") (defcustom ido-ubiquitous-default-state 'enable "Default ido-ubiquitous mode of operation for commands with no override. This can be set to one of three options: * `enable': use normal ido completion; * `enable-old': use ido completion, but with emulation of the old-style default selection of `completing-read'; * `disable': use non-ido completion. Command-specific and function-specific overrides are available to override this default for specific commands/functions. See `ido-ubiquitous-command-overrides' and `ido-ubiquitous-function-overrides'. The `enable-old' option swaps the behavior of RET and C-j but only for the first keypress after beginning completion. Specifically, on the first keypress, RET will return an empty string and C-j will return the first item on the list. The purpose of this is to emulate a legacy compatibility quirk of `completing-read'. From the `completing-read' docstring: > If the input is null, `completing-read' returns DEF, or the > first element of the list of default values, or an empty string > if DEF is nil, regardless of the value of REQUIRE-MATCH. This odd behavior is required for compatibility with an old-style usage pattern whereby the default was requested by returning an empty string. In this mode, the caller receives the empty string and handles the default case manually, while `completing-read' never has any knowledge of the default. This is a problem for ido, which normally returns the first element in the list, not an empty string, when the input is empty and you press RET. Without knowledge of the default, it cannot ensure that the default is first on the list, so returning the first item is not the correct behavior. Instead, it must return an empty string like `completing-read'. The `disable' mode is available as a default, which seems counterintuitive. But this allows you, if you so desire, to enable ido-ubiquitous selectively for only a few specific commands using overrides and disable it for everything else." :type '(choice :tag "Default mode" (const :menu-tag "Disable" :tag "Disable ido-ubiquitous" disable) (const :menu-tag "Enable" :tag "Enable ido-ubiquitous in normal default mode" enable) (const :menu-tag "Enable old-style default" :tag "Enable ido-ubiquitous in old-style default mode" enable-old)) :group 'ido-ubiquitous) (make-obsolete-variable 'ido-ubiquitous-enable-old-style-default "This variable no longer has any effect. Set `ido-ubiquitous-default-state' to `enable-old' instead." "ido-ubiquitous 3.0") (defconst ido-ubiquitous-default-command-overrides '(;; If you want ido for M-x, install smex (disable exact "execute-extended-command") ;; Wanderlust uses new-style default (enable prefix "wl-") ;; Info functions use old-style default selection (enable-old prefix "Info-") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/4 (enable exact "webjump") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/28 (enable regexp "\\`\\(find\\|load\\|locate\\)-library\\'") ;; https://github.com/bbatsov/prelude/issues/488 ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/44 ;; tmm implements its own non-standard completion mechanics (disable prefix "tmm-") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/47 ;; theme functions don't need old-style compatibility (enable regexp "\\`\\(load\\|enable\\|disable\\|describe\\|custom-theme-visit\\)-theme\\'") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/79 (enable-old prefix "bbdb-") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/83 (enable-old exact "where-is") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/60 (disable exact "todo-add-category") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/51 (enable exact "find-tag") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/89 (enable prefix "etags-select-") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/110 (enable regexp "\\`describe-\\(function\\|variable\\)\\'") ) ; Close paren on separate line for better VC diffs "Default value of `ido-ubiquitous-command-overrides'. You can restore these using the command `ido-ubiquitous-restore-default-overrides'.") (defconst ido-ubiquitous-default-function-overrides '((disable exact "read-file-name") (disable exact "read-file-name-internal") (disable exact "read-buffer") (disable exact "gnus-emacs-completing-read") (disable exact "gnus-iswitchb-completing-read") (disable exact "grep-read-files") (disable exact "magit-builtin-completing-read") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/36 (enable exact "bookmark-completing-read") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/4 (enable-old exact "webjump-read-choice") (enable-old exact "webjump-read-url-choice") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/9 (disable exact "isearchp-read-unicode-char") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/38 (enable exact "read-char-by-name") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/39 (disable exact "Info-read-node-name") ;; https://github.com/purcell/emacs.d/issues/182#issuecomment-44212927 (disable exact "tmm-menubar") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/58 ;; https://github.com/mooz/js2-mode/issues/181 (enable exact "imenu--completion-buffer") ;; https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/74 (enable-old exact "auto-insert") ) ; Close paren on separate line for better VC diffs "Default value of `ido-ubiquitous-function-overrides'. You can restore these using the command `ido-ubiquitous-restore-default-overrides'.") (defcustom ido-ubiquitous-command-overrides ido-ubiquitous-default-command-overrides "List of command override specifications for ido-ubiquitous Each override specification describes how ido-ubiquitous should behave one or many commands. A specification has the form `(BEHAVIOR MATCH-TYPE MATCH-TEXT)'. BEHAVIOR is one of the following: * `disable': ido-ubiquitous should not be used at all for the specified commands; * `enable': ido-ubiquitous may be used with the specified commands, without emulating the old-style default selection of `completing-read'; * `enable-old': ido-ubiquitous may be used with the specified commands, and should emulate the old-style default selection of `completing-read'. MATCH-TYPE affects how MATCH-TEXT is interpreted, as follows: * `exact': the specification only affects the one command whose name is MATCH-TEXT; * `prefix': the specification affects any command whose name starts with MATCH-TEXT (This is useful for specifying a certain behavior for an entire package); * `regexp': the specification affects any command whose name matches MATCH-TEXT (with MATCH-TEXT being interpreted as a regular expression) MATCH-TEXT should be a string. Since this variable's has a somewhat complex structure, it is recommended that you set this variable through Customize. Note that this variable only affects *commands*, which are functions marked as interactive. See `ido-ubiquitous-function-overrides' for how to modify the behavior of ido-ubiquitous for arbitrary functions. Note: If multiple overrides match the same commmand, the first one in the list will take precedence. If you need to add a new specification to this list, please also file a bug report at https://github.com/DarwinAwardWinner/ido-ubiquitous/issues" :type '(repeat ido-ubiquitous-command-override-spec) :group 'ido-ubiquitous) (defmacro ido-ubiquitous-with-override (override &rest body) "Eval BODY with specified OVERRIDE in place. The OVERRIDE argument is evaluated normally, so if it is a literal symbol, it must be quoted. See `ido-ubiquitous-command-overrides' for valid override types." (declare (indent 1)) ;; Eval override `(let ((ido-ubiquitous-next-override ,override)) ,@body)) (defun ido-ubiquitous-apply-function-override (func override) "Set the override property on FUNC to OVERRIDE and set up advice to apply the override." (setq func (ido-ubiquitous--as-symbol func) override (ido-ubiquitous--as-symbol override)) (if (memq override '(disable enable enable-old nil)) (progn (put func 'ido-ubiquitous-override override) (when override (let ((docstring (format "Override ido-ubiquitous behavior in %s if its `ido-ubiquitous-override' property is non-nil." func))) (eval `(defadvice ,func (around ido-ubiquitous-override activate) ,docstring (let* ((func ',func) (override (get func 'ido-ubiquitous-override))) (when override (ido-ubiquitous--debug-message "Using override `%s' for function `%s'" override func)) (ido-ubiquitous-with-override override ad-do-it))))))) (display-warning 'ido-ubiquitous (format "Ignoring invalid override action `%s' for function `%s' found in `ido-ubiquitous-function-overrides'." override func) :warning))) (defun ido-ubiquitous-set-function-overrides (sym newval) "Custom setter function for `ido-ubiquitous-function-overrides'. In addition to setting the variable, this also sets up advice on each function to apply the appropriate override." ;; Unset all previous overrides (when (boundp sym) (let ((oldval (eval sym))) (cl-loop for (_action _match-type func) in oldval do (ido-ubiquitous-apply-function-override func nil)))) ;; Ensure that function names are strings, not symbols (setq newval (cl-loop for (action match-type func) in newval collect (list action match-type (ido-ubiquitous--as-string func)))) ;; set new overrides (cl-loop for override in newval for (action match-type func) = override ;; Remove duplicate overrides if (member func overridden-functions) do (display-warning 'ido-ubiquitous (format "Removing duplicate override for function `%s'" func)) ;; Apply valid overrides else if (eq match-type 'exact) do (ido-ubiquitous-apply-function-override func action) and collect func into overridden-functions and collect override into final-value ;; Remove invalid overrides else do (display-warning 'ido-ubiquitous (format "Removing invalid function override match-type `%s' for function `%s'; only match-type `exact' is supported in `ido-ubiquitous-function-overrides'." match-type func)) ;; Set the value to only the overrides that were actually ;; applied. finally return (set-default sym final-value))) (defcustom ido-ubiquitous-auto-update-overrides 'notify "Whether to add new overrides when updating ido-ubiquitous. Ido-ubiquitous comes with a default set of overrides for commands that are known to require them. New versions of ido-ubiquitous may come with updates to the default overrides as more commands are discovered to require them. However, customizing your own overrides would normally prevent you from receiving these updates, since Emacs will not overwrite your customizations. To resolve this problem, you can set this variable to `t', and then ido-ubiquitous can automatically add any new built-in overrides whenever it is updated. (Actually, the update will happen the next time Emacs is restarted after the update.) This allows you to add your own overrides but still receive updates to the default set. The default overrides will always be added with lower precedence than user-added ones. If you want ido-ubiquitous to just notify you about new default overrides instead of adding them itself, set this variable to `notify'. If you don't want this auto-update behavior at all, set it to `nil'. (Note that having this option enabled effectively prevents you from removing any of the built-in default overrides, since they will simply be re-added the next time Emacs starts. However, your custom overrides will still take precedence, so this shouldn't be a problem.)" :type '(choice :tag "When new overrides are available:" (const :menu-tag "Auto-add" :tag "Add them automatically" t) (const :menu-tag "Notify" :tag "Notify the user about them" notify) (const :menu-tag "Ignore" :tag "Ignore them" nil)) :group 'ido-ubiquitous) (defcustom ido-ubiquitous-function-overrides ido-ubiquitous-default-function-overrides "List of function override specifications for ido-ubiquitous Function override specifications have a similar structure to command override specifications (see `ido-ubiquitous-command-overrides'). A function override specification has the form `(BEHAVIOR MATCH-TYPE MATCH-TEXT)'. However, `MATCH-TYPE' may ONLY be `exact'; No other match type is supported. Note: If multiple overrides are set for the same function, the first one in the list will take precedence, and the rest will be ignored and deleted from the override list, with a warning. Invalid override specifications will also be deleted with a warning. If you need to add a new specification to this list, please also file a bug report at https://github.com/DarwinAwardWinner/ido-ubiquitous/issues Setting this variable directly has no effect. You must set it through Customize." :type '(repeat ido-ubiquitous-function-override-spec) :set 'ido-ubiquitous-set-function-overrides :group 'ido-ubiquitous) (defcustom ido-ubiquitous-allow-on-functional-collection nil "Allow ido completion when COLLECTION is a function. The `completing-read' function allows its COLLECTION argument to be a function instead of a list of choices. Some such functions simply return a list of completions and are suitable for use with ido, but others implement more complex behavior and will result in incorrect behavior if used with ido. Since there is no way to tell the difference, this preference defaults to nil, which means that ido-ubiquitous will not work when COLLECTION is a function unless there is a specific override in effect. To disable this safeguard and GUARANTEE ERRORS on some functions, you may set this to non-nil, but this is not recommended." :type 'boolean :group 'ido-ubiquitous) ;;; ido-ubiquitous core ;; These variable are used to make ido-ubiquitous work properly in the ;; case that `completing-read' is called recursively (which is ;; possible when `enable-recursive-minibuffers' is non-nil.) (defvar ido-ubiquitous-enable-next-call nil "If non-nil, then the next call to `ido-completing-read' is by ido-ubiquitous.") (defvar ido-ubiquitous-enable-this-call nil "If non-nil, then the current call to `ido-completing-read' is by ido-ubiquitous.") (defvar ido-ubiquitous-next-override nil "This holds the override to be applied on the next call to `completing-read'. It's value can be nil or one of the symbols `disable', `enable', or `enable-old'. You should not modify this variable directly. Instead use the macro `ido-ubiquitous-with-override'.") (defvar ido-ubiquitous-active-override nil "This holds the override being applied to the current call to `completing-read'. It's value can be nil or one of the symbols `disable', `enable', or `enable-old'. You should not modify this variable directly. Instead use the macro `ido-ubiquitous-with-override'.") (defvar ido-ubiquitous-active-state nil "This holds the ido-ubiquitous mode of operation for the current call to `completing-read'. It's value can be nil or one of the symbols `disable', `enable', or `enable-old'. You should not modify this variable directly.") (defadvice ido-completing-read (around ido-ubiquitous activate) "Enable ido-ubiquitous features if this call was done through ido-ubiquitous. This advice ensures that `ido-ubiquitous-enable-this-call' is set properly while `ido-completing-read' is executing. This variable is used to determine whether to enable certain behaviors only for ido-ubiquitous, not for ordinary ido completion." ;; Set "this" and clear "next" so it doesn't apply to nested calls. (let* ((ido-ubiquitous-enable-this-call ido-ubiquitous-enable-next-call) (ido-ubiquitous-enable-next-call nil) (ido-ubiquitous-initial-item nil)) ad-do-it)) ;; Signal used to trigger fallback (don't use `define-error' because ;; it's only supported in 24.4 and up) (put 'ido-ubiquitous-fallback 'error-conditions '(ido-ubiquitous-fallback error)) (put 'ido-ubiquitous-fallback 'error-message "ido-ubiquitous-fallback") (defun completing-read-ido-ubiquitous (prompt collection &optional predicate require-match initial-input hist def inherit-input-method) "ido-based method for reading from the minibuffer with completion. See `completing-read' for the meaning of the arguments. This function is a wrapper for `ido-completing-read' designed to be used as the value of `completing-read-function'. Importantly, it detects edge cases that ido cannot handle and uses normal completion for them." (let (;; Save the original arguments in case we need to do the ;; fallback (orig-args (list prompt collection predicate require-match initial-input hist def inherit-input-method))) ;; Outer `condition-case' is the fallback handler (condition-case sig ;; Inner `condition-case' converts any unexpected errors into ;; fallback signals. (condition-case err (let* (;; Set the active override and clear the "next" one so it ;; doesn't apply to nested calls. (ido-ubiquitous-active-override ido-ubiquitous-next-override) (ido-ubiquitous-next-override nil) ;; Apply the active override, if any (ido-ubiquitous-active-state (or ido-ubiquitous-active-override ido-ubiquitous-default-state 'enable))) ;; If ido-ubiquitous is disabled this time, fall back (when (eq ido-ubiquitous-active-state 'disable) (signal 'ido-ubiquitous-fallback "`ido-ubiquitous-active-state' is `disable'")) ;; Handle a collection that is a function: either expand ;; completion list now or fall back (when (functionp collection) (if (or ido-ubiquitous-allow-on-functional-collection (memq ido-ubiquitous-active-override '(enable enable-old))) (setq collection (all-completions "" collection predicate) ;; `all-completions' will apply the predicate, ;; so it now becomes redundant. predicate nil) (signal 'ido-ubiquitous-fallback "COLLECTION is a function and there is no override"))) (let ((ido-ubiquitous-enable-next-call t)) (ido-completing-read+ prompt collection predicate require-match initial-input hist def inherit-input-method))) (error (signal 'ido-ubiquitous-fallback (format "ido-ubiquitous encountered an unexpected error: %S" err)))) ;; Handler for ido-ubiquitous-fallback signal (ido-ubiquitous-fallback (ido-ubiquitous--explain-fallback sig) (apply ido-cr+-fallback-function orig-args))))) (define-obsolete-function-alias 'completing-read-ido 'completing-read-ido-ubiquitous "ido-ubiquitous 3.0") ;;; Old-style default support (defvar ido-ubiquitous-initial-item nil "The first item selected when ido starts. This is initialized to the first item in the list of completions when ido starts, and is cleared when any character is entered into the prompt or the list is cycled. If it is non-nil and still equal to the first item in the completion list when ido exits, then if `ido-ubiquitous-active-state' is `enable-old', ido returns an empty string instead of the first item on the list.") (defmacro ido-ubiquitous-set-initial-item (item) "Wrapper for `(setq ido-ubiquitous-initial-item ITEM)'. This wrapper differs from simply doing `(setq ido-ubiquitous-initial-item ITEM)' in several ways. First, it has no effect (and does not evaluate ITEM) unless `ido-ubiquitous-active-state' is `enable-old'. Second, it emits appropriate debug messages." `(when (eq ido-ubiquitous-active-state 'enable-old) (let ((item ,item)) (cond (item (ido-ubiquitous--debug-message "Setting `ido-ubiquitous-initial-item' to `%S'." item)) (ido-ubiquitous-initial-item (ido-ubiquitous--debug-message "Clearing `ido-ubiquitous-initial-item'."))) (setq ido-ubiquitous-initial-item item)))) (defadvice ido-read-internal (before ido-ubiquitous-clear-initial-item activate) (ido-ubiquitous-set-initial-item nil)) (defadvice ido-make-choice-list (after ido-ubiquitous-set-initial-item activate) (ido-ubiquitous-set-initial-item (when (and ad-return-value (listp ad-return-value)) (car ad-return-value)))) (defadvice ido-next-match (after ido-ubiquitous-clear-initial-item activate) (ido-ubiquitous-set-initial-item nil)) (defadvice ido-prev-match (after ido-ubiquitous-clear-initial-item activate) (ido-ubiquitous-set-initial-item nil)) ;; Clear initial item after `self-insert-command' (defun ido-ubiquitous-post-insert-hook () (eval '(ido-ubiquitous-set-initial-item nil))) (defun ido-ubiquitous-ido-minibuffer-setup-hook () (add-hook 'post-self-insert-hook #'ido-ubiquitous-post-insert-hook nil 'local)) (add-hook 'ido-minibuffer-setup-hook #'ido-ubiquitous-ido-minibuffer-setup-hook) (defun ido-ubiquitous-should-use-old-style-default () "Returns non nil if ido-ubiquitous should emulate old-style default. This function simply encapsulates all the checks that need to be done in order to decide whether to swap RET and C-j. See `ido-ubiquitous-default-state' for more information." ;; These checks outside the loop don't produce debug messages (and ;; Only if old-style default enabled (eq ido-ubiquitous-active-state 'enable-old) ;; This loop is just an implementation of `and' that reports which ;; arg was nil for debugging purposes. (cl-loop for test in '((bound-and-true-p ido-cur-item) ;; Only if completing a list, not a buffer or file (eq ido-cur-item 'list) ;; Only if this call was done through ido-ubiquitous ido-ubiquitous-enable-this-call ;; Only if default is nil (null ido-default-item) ;; Only if input is empty (string= ido-text "") ;; Only if `ido-ubiquitous-initial-item' hasn't been cleared ido-ubiquitous-initial-item ;; Only if initial item hasn't changed (string= (car ido-cur-list) ido-ubiquitous-initial-item)) for test-result = (eval test) if (not test-result) do (ido-ubiquitous--debug-message "Not enabling old-style default selection because `%S' is nil" test) and return nil finally do (ido-ubiquitous--debug-message "Enabling old-style default selection") finally return t))) (defadvice ido-exit-minibuffer (around ido-ubiquitous-old-style-default-compat activate) "Emulate a quirk of `completing-read'. > If the input is null, `completing-read' returns DEF, or the > first element of the list of default values, or an empty string > if DEF is nil, regardless of the value of REQUIRE-MATCH. See `ido-ubiquitous-default-state', which controls whether this advice has any effect." (condition-case nil (if (ido-ubiquitous-should-use-old-style-default) (let ((ido-ubiquitous-active-state 'enable)) (ido-select-text)) ad-do-it) (error (display-warning 'ido-ubiquitous "Advice on `ido-exit-minibuffer' failed." :warning) ad-do-it)) (ido-ubiquitous-set-initial-item nil)) (defadvice ido-select-text (around ido-ubiquitous-old-style-default-compat activate) "Emulate a quirk of `completing-read'. > If the input is null, `completing-read' returns DEF, or the > first element of the list of default values, or an empty string > if DEF is nil, regardless of the value of REQUIRE-MATCH. See `ido-ubiquitous-default-state', which controls whether this advice has any effect." (condition-case nil (if (ido-ubiquitous-should-use-old-style-default) (let ((ido-ubiquitous-active-state 'enable)) (ido-exit-minibuffer)) ad-do-it) (error (display-warning 'ido-ubiquitous "Advice on `ido-select-text' failed." :warning) ad-do-it)) (ido-ubiquitous-set-initial-item nil)) ;;; Overrides (defun ido-ubiquitous--overrides-have-same-target-p (o1 o2) (cl-destructuring-bind (oride1 type1 text1) o1 (cl-destructuring-bind(oride2 type2 text2) o2 ;; Avoid warnings about unused vars oride1 oride2 (and (string= text1 text2) (eq type1 type2))))) (defun ido-ubiquitous--combine-override-lists (olist1 olist2) "Append OLIST2 to OLIST1, but remove redundant elements. Redundancy is determined using `ido-ubiquitous--overrides-have-same-target-p'." (let ((olist2 (cl-remove-if (lambda (o2) (cl-member o2 olist1 :test #'ido-ubiquitous--overrides-have-same-target-p)) olist2))) (append olist1 olist2))) (defun ido-ubiquitous-update-overrides (&optional save quiet) "Re-add the default overrides without erasing custom overrides. This is useful after an update of ido-ubiquitous that adds new default overrides. See `ido-ubiquitous-auto-update-overrides' for more information. If SAVE is non-nil, also save the overrides to the user's custom file (but only if they were already customized). When called interactively, a prefix argument triggers a save. When called from Lisp code, this function returns the list of variables whose values were modified. In particular, it returns non-nil if any variables were modified, and nil if no modifications were made." (interactive "P") (let ((unmodified-vars nil) (updated-vars nil) (final-message-lines nil) (final-message-is-warning nil)) (cl-loop for (var def) in '((ido-ubiquitous-command-overrides ido-ubiquitous-default-command-overrides) (ido-ubiquitous-function-overrides ido-ubiquitous-default-function-overrides)) do (let* ((var-state (custom-variable-state var (eval var))) (curval (eval var)) (defval (eval def)) (newval (ido-ubiquitous--combine-override-lists curval defval))) (cond ;; Nothing to add to var, do nothing ((and (equal curval newval) (eq var-state 'saved)) (ido-ubiquitous--debug-message "No need to modify value of option `%s'" var) (push var unmodified-vars)) ;; Var is not customized, just set the new default ((eq var-state 'standard) (ido-ubiquitous--debug-message "Setting uncustomized option `%s' to its default value" var) (push var unmodified-vars) (set var defval)) ;; Var is saved to custom.el, set and save new value (if ;; SAVE is t) ((and save (eq var-state 'saved)) (ido-ubiquitous--debug-message "Updating option `%s' with new overrides and saving it." var) (push var updated-vars) (customize-save-variable var newval)) ;; Var is modified but not saved (or SAVE is nil), update it ;; but don't save it (t (ido-ubiquitous--debug-message "Updating option `%s' with new overrides but not saving it for future sessions." var) (push var updated-vars) (customize-set-variable var newval))))) (unless quiet ;; Now compose a single message that summarizes what was done (if (null updated-vars) (push "No updates to ido-ubiquitous override variables were needed." final-message-lines) (push (format "Updated the following ido-ubiquitous override variables: %S" (sort updated-vars #'string<)) final-message-lines) (if save (push "All updated variables were successfully saved." final-message-lines) (push "However, they have not been saved for future sessions. To save them, re-run this command with a prefix argument: `C-u M-x ido-ubiquitous-update-overrides'; or else manually inspect and save their values using `M-x customize-group ido-ubiquitous'." final-message-lines) (setq final-message-is-warning t))) (if final-message-is-warning (display-warning 'ido-ubiquitous (mapconcat 'identity (nreverse final-message-lines) "\n")) (message (mapconcat 'identity (nreverse final-message-lines) "\n")))) updated-vars)) (defun ido-ubiquitous--find-override-updates (current-value available-updates) (cl-set-difference (ido-ubiquitous--combine-override-lists current-value available-updates) current-value)) (defun ido-ubiquitous--maybe-update-overrides () "Maybe call `ido-ubiquitous-update-overrides. See `ido-ubiquitous-auto-update-overrides." (if ido-ubiquitous-auto-update-overrides (let* ((command-override-updates (ido-ubiquitous--find-override-updates ido-ubiquitous-command-overrides ido-ubiquitous-default-command-overrides)) (function-override-updates (ido-ubiquitous--find-override-updates ido-ubiquitous-function-overrides ido-ubiquitous-default-function-overrides)) (update-count (+ (length command-override-updates) (length function-override-updates)))) (if (> update-count 0) (if (eq ido-ubiquitous-auto-update-overrides 'notify) (display-warning 'ido-ubiquitous (format "There are %s new overrides available. Use `M-x ido-ubiquitous-update-overrides' to enable them. (See `ido-ubiquitous-auto-update-overrides' for more information.)" update-count)) (ido-ubiquitous--debug-message "Applying override updates.") (ido-ubiquitous-update-overrides t)) (ido-ubiquitous--debug-message "No override updates availble."))) (ido-ubiquitous--debug-message "Skipping override updates by user preference."))) (define-obsolete-function-alias 'ido-ubiquitous-restore-default-overrides 'ido-ubiquitous-update-overrides "ido-ubiquitous 3.9") (defun ido-ubiquitous-spec-match (spec symbol) "Returns t if SPEC matches SYMBOL (which should be a function name). See `ido-ubiquitous-command-overrides'. If the match spec is invalid or any other error occurs, the error is demoted to a warning and the function returns nil." (condition-case err (when (and symbol (symbolp symbol)) (cl-destructuring-bind (type text) spec (let ((matcher (cdr (assoc type ido-ubiquitous-spec-matchers))) (text (ido-ubiquitous--as-string text)) (symname (ido-ubiquitous--as-string symbol))) (if matcher (funcall matcher text symname) ;; If the matcher is invalid, issue a warning and return ;; nil. (error "Unknown match spec type \"%s\". See `ido-ubiquitous-spec-matchers' for valid types." type) nil)))) (error (display-warning 'ido-ubiquitous "Error during ido-ubiquitous spec matching: %S" err) nil))) (defun ido-ubiquitous-get-command-override (cmd) "Return the override associated with the command CMD. If there is no override set for CMD in `ido-ubiquitous-command-overrides', return nil." (when (and cmd (symbolp cmd)) (cl-loop for override in ido-ubiquitous-command-overrides for (action . spec) = override for valid-action = (and (memq action '(disable enable enable-old nil)) (assoc (car spec) ido-ubiquitous-spec-matchers)) unless valid-action do (progn (display-warning 'ido-ubiquitous (format "Removing invalid override `%S' from `ido-ubiquitous-command-overrides'" (cons action spec)) :warning) (setq ido-ubiquitous-command-overrides (remove override ido-ubiquitous-command-overrides))) when (and valid-action (ido-ubiquitous-spec-match spec cmd)) return action finally return nil))) ;;; Workaround for https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/24 ;; When `call-interactively' is advised, `called-interactively-p' ;; always returns nil. So we redefine it (and `interactive-p') to test ;; the correct condition. (defsubst ido-ubiquitous--looks-like-advised-orig (func) "Returns t if FUNC is a symbol starting with \"ad-Orig-\". Such symbols are used to store the original definitions of functions that have been advised by `defadvice' or similar." (and (symbolp func) (string-prefix-p "ad-Orig-" (symbol-name func)))) (defsubst ido-ubiquitous--looks-like-call-interactively (func) "Returns t if FUNC looks like the function `call-interactively'. FUNC \"looks like\" `call-interactively' if it is the literal symbol `call-interactively', or the value of `(symbol-function 'call-interactively)', or a symbol whose `symbol-function' is the same as that of `call-interactively'. This function is used to determine whether a given function was \"called by\" `call-interactively' and therefore was called interactively." (when func (eq (symbol-function 'call-interactively) (if (symbolp func) (symbol-function func) func)))) (defun ido-ubiquitous--backtrace-from (fun) "Return all backtrace frames, starting with the one for FUN. FUN may be a list of functions, in which case the first one found on the stack will be used." (let ((stack (cl-loop for i upfrom 0 for frame = (backtrace-frame i) while frame collect frame)) (funcs (if (functionp fun) (list fun) fun))) (while (and stack (not (memq (cl-cadar stack) funcs))) (setq stack (cdr stack))) stack)) (defun ido-ubiquitous--clean-advice-from-backtrace (stack) "Takes a stack trace and cleans all evidence of advice. Specifically, for each call to a function starting with \"ad-Orig-\", that call and all prior calls up to but not including the advised function's original name are deleted from the stack." (let ((skipping-until nil)) (cl-loop for frame in stack for func = (cadr frame) ;; Check if we found the frame we we're skipping to if (and skipping-until (eq func skipping-until)) do (setq skipping-until nil) ;; If we're looking at an the original form of an advised ;; function, skip until the real name of that function. if (and (not skipping-until) (ido-ubiquitous--looks-like-advised-orig func)) do (setq skipping-until (intern (substring (symbol-name func) (eval-when-compile (length "ad-Orig-"))))) unless skipping-until collect frame))) (defsubst ido-ubiquitous--interactive-internal () "Equivalent of the INTERACTIVE macro in the Emacs C source. This is an internal function that should never be called directly. See the C source for the logic behind this function." (and (not executing-kbd-macro) (not noninteractive))) (defun ido-ubiquitous--interactive-p-internal () "Equivalent of C function \"interactive_p\". This is an internal function that should never be called directly. See the C source for the logic behind this function." (let ((stack ;; We clean advice from the backtrace. This ensures that we ;; get the right answer even if `call-interactively' has been ;; advised. (ido-ubiquitous--clean-advice-from-backtrace (cdr (ido-ubiquitous--backtrace-from '(called-interactively-p interactive-p)))))) ;; See comments in the C function for the logic here. (while (and stack (or (eq (cl-cadar stack) 'bytecode) (null (caar stack)))) (setq stack (cdr stack))) ;; Top of stack is now the function that we want to know ;; about. Pop it, then check if the next function is ;; `call-interactively', using a more permissive test than the default. (ido-ubiquitous--looks-like-call-interactively (cl-cadadr stack)))) (defadvice call-interactively (around ido-ubiquitous activate) "Implements the behavior specified in `ido-ubiquitous-command-overrides'." (let* ((cmd (ad-get-arg 0)) (override (ido-ubiquitous-get-command-override cmd))) (when override (ido-ubiquitous--debug-message "Using override `%s' for command `%s'" override cmd)) (ido-ubiquitous-with-override override ad-do-it))) ;; Work around `called-interactively-p' in Emacs 24.3 and earlier, ;; which always returns nil when `call-interactively' is advised. (when (not (and (featurep 'nadvice) (boundp 'called-interactively-p-functions))) (defadvice interactive-p (around ido-ubiquitous activate) "Return the correct result when `call-interactively' is advised. This advice completely overrides the original definition." (condition-case nil (setq ad-return-value (and (ido-ubiquitous--interactive-internal) (ido-ubiquitous--interactive-p-internal))) ;; In case of error in the advice, fall back to the default ;; implementation (error ad-do-it))) (defadvice called-interactively-p (around ido-ubiquitous activate) "Return the correct result when `call-interactively' is advised. This advice completely overrides the original definition." (condition-case nil (setq ad-return-value (and (or (ido-ubiquitous--interactive-internal) (not (eq kind 'interactive))) (ido-ubiquitous--interactive-p-internal))) ;; In case of error in the advice, fall back to the default ;; implementation (error ad-do-it)))) ;;; Other (defsubst ido-ubiquitous--fixup-old-advice () ;; Clean up old versions of ido-ubiquitous advice if they exist (ignore-errors (ad-remove-advice 'completing-read 'around 'ido-ubiquitous)) (ignore-errors (ad-remove-advice 'ido-completing-read 'around 'detect-replacing-cr)) (ignore-errors (ad-remove-advice 'ido-magic-forward-char 'before 'ido-ubiquitous-fallback)) (ignore-errors (ad-remove-advice 'ido-magic-backward-char 'before 'ido-ubiquitous-fallback)) (ignore-errors (ad-remove-advice 'ido-exit-minibuffer 'around 'compatibility)) (ad-activate-all)) (defsubst ido-ubiquitous--fixup-old-magit-overrides () (let ((old-override '(disable prefix "magit-")) (new-override '(disable exact "magit-builtin-completing-read"))) (when (member old-override ido-ubiquitous-command-overrides) (customize-set-variable 'ido-ubiquitous-command-overrides (remove old-override ido-ubiquitous-command-overrides)) (unless (member new-override ido-ubiquitous-function-overrides) (customize-set-variable 'ido-ubiquitous-function-overrides (append ido-ubiquitous-function-overrides (list new-override)))) (display-warning 'ido-ubiquitous "Fixing obsolete magit overrides. Magit has changed recently such that the old override that ido-ubiquitous defined for it now causes problems. This old override has been automatically removed and the new one added. Please use `M-x customize-group ido-ubiquitous' and review the override variables and save them to your customization file." :warning)))) (defun ido-ubiquitous-initialize () "Do initial setup for ido-ubiquitous. This only needs to be called once when the file is first loaded. It cleans up any traces of old versions of ido-ubiquitous and then sets up the mode." (ido-ubiquitous--fixup-old-advice) (ido-ubiquitous--fixup-old-magit-overrides) (ido-ubiquitous--maybe-update-overrides) ;; Make sure the mode is turned on/off as specified by the value of ;; the mode variable (ido-ubiquitous-mode (if ido-ubiquitous-mode 1 0))) (ido-ubiquitous-initialize) (provide 'ido-ubiquitous) ;; Local Variables: ;; indent-tabs-mode: nil ;; End: ;;; ido-ubiquitous.el ends here ido-ubiquitous-3.14/ido-completing-read+.el0000644000175000017500000003056512731324552020512 0ustar dogslegdogsleg;;; ido-completing-read+.el --- A completing-read-function using ido -*- lexical-binding: t -*- ;; Copyright (C) 2015 Ryan C. Thompson ;; Filename: ido-completing-read+.el ;; Author: Ryan Thompson ;; Created: Sat Apr 4 13:41:20 2015 (-0700) ;; Version: 3.14 ;; Package-Requires: ((emacs "24.1") (cl-lib "0.5")) ;; URL: https://github.com/DarwinAwardWinner/ido-ubiquitous ;; Keywords: ido, completion, convenience ;; This file is NOT part of GNU Emacs. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Commentary: ;; This package implements the `ido-completing-read+' function, which ;; is a wrapper for `ido-completing-read'. Importantly, it detects ;; edge cases that ordinary ido cannot handle and either adjusts them ;; so ido *can* handle them, or else simply falls back to Emacs' ;; standard completion instead. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; 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 GNU Emacs. If not, see . ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Code: (defconst ido-completing-read+-version "3.14" "Currently running version of ido-ubiquitous. Note that when you update ido-completing-read+, this variable may not be updated until you restart Emacs.") (require 'ido) (require 'cl-lib) ;;; Debug messages (define-minor-mode ido-cr+-debug-mode "If non-nil, ido-cr+ will print debug info. Debug info is printed to the *Messages* buffer." nil :global t :group 'ido-completing-read-plus) ;; Defined as a macro for efficiency (args are not evaluated unless ;; debug mode is on) (defmacro ido-cr+--debug-message (format-string &rest args) `(when ido-cr+-debug-mode (message (concat "ido-completing-read+: " ,format-string) ,@args))) ;;; Core code ;;;###autoload (defvar ido-cr+-enable-next-call nil "If non-nil, then the next call to `ido-completing-read' is by `ido-completing-read+'.") ;;;###autoload (defvar ido-cr+-enable-this-call nil "If non-nil, then the current call to `ido-completing-read' is by `ido-completing-read+'") (defgroup ido-completing-read-plus nil "Extra features and compatibility for `ido-completing-read'." :group 'ido) (defcustom ido-cr+-fallback-function ;; Initialize to the current value of `completing-read-function', ;; unless that is already set to the ido completer, in which case ;; use `completing-read-default'. (if (memq completing-read-function '(ido-completing-read+ ido-completing-read ;; Current ido-ubiquitous function completing-read-ido-ubiquitous ;; Old ido-ubiquitous functions that shouldn't be used completing-read-ido ido-ubiquitous-completing-read)) 'completing-read-default completing-read-function) "Alternate completing-read function to use when ido is not wanted. This will be used for functions that are incompatible with ido or if ido cannot handle the completion arguments. It will also be used when the user requests non-ido completion manually via C-f or C-b." :type '(choice (const :tag "Standard emacs completion" completing-read-default) (function :tag "Other function")) :group 'ido-completing-read-plus) (defcustom ido-cr+-max-items 30000 "Max collection size to use ido-cr+ on. If `ido-completing-read+' is called on a collection larger than this, the fallback completion method will be used instead. To disable fallback based on collection size, set this to nil." :type '(choice (const :tag "No limit" nil) (integer :tag "Limit" :value 30000 :validate (lambda (widget) (let ((v (widget-value widget))) (if (and (integerp v) (> v 0)) nil (widget-put widget :error "This field should contain a positive integer") widget))))) :group 'ido-completing-read-plus) ;;;###autoload (defcustom ido-cr+-replace-completely nil "If non-nil, replace `ido-completeing-read' completely with ido-cr+. Enabling this may interfere with or cause errors in other packages that use `ido-completing-read'. If you discover any such incompatibilities, please file a bug report at https://github.com/DarwinAwardWinner/ido-ubiquitous/issues" :type 'boolean) ;; Signal used to trigger fallback (put 'ido-cr+-fallback 'error-conditions '(ido-cr+-fallback error)) (put 'ido-cr+-fallback 'error-message "ido-cr+-fallback") (defun ido-cr+--explain-fallback (arg) ;; This function accepts a string, or an ido-cr+-fallback ;; signal. (when ido-cr+-debug-mode (when (and (listp arg) (eq (car arg) 'ido-cr+-fallback)) (setq arg (cdr arg))) (ido-cr+--debug-message "Falling back to `%s' because %s." ido-cr+-fallback-function arg))) ;;;###autoload (defun ido-completing-read+ (prompt collection &optional predicate require-match initial-input hist def inherit-input-method) "ido-based method for reading from the minibuffer with completion. See `completing-read' for the meaning of the arguments. This function is a wrapper for `ido-completing-read' designed to be used as the value of `completing-read-function'. Importantly, it detects edge cases that ido cannot handle and uses normal completion for them." (let (;; Save the original arguments in case we need to do the ;; fallback (orig-args (list prompt collection predicate require-match initial-input hist def inherit-input-method))) (condition-case sig (progn (cond (inherit-input-method (signal 'ido-cr+-fallback "ido cannot handle non-nil INHERIT-INPUT-METHOD")) ((bound-and-true-p completion-extra-properties) (signal 'ido-cr+-fallback "ido cannot handle non-nil `completion-extra-properties'")) ((functionp collection) (signal 'ido-cr+-fallback "ido cannot handle COLLECTION being a function"))) ;; Expand all possible completions (setq collection (all-completions "" collection predicate)) ;; Check for excessively large collection (when (and ido-cr+-max-items (> (length collection) ido-cr+-max-items)) (signal 'ido-cr+-fallback (format "there are more than %i items in COLLECTION (see `ido-cr+-max-items')" ido-cr+-max-items))) ;; ido doesn't natively handle DEF being a list. If DEF is a ;; list, prepend it to COLLECTION and set DEF to just the ;; car of the default list. (when (and def (listp def)) (setq collection (append def (nreverse (cl-set-difference collection def))) def (car def))) ;; Work around a bug in ido when both INITIAL-INPUT and ;; DEF are provided. (let ((initial (or (if (consp initial-input) (car initial-input) initial-input) ""))) (when (and def initial (stringp initial) (not (string= initial ""))) ;; Both default and initial input were provided. So keep ;; the initial input and preprocess the collection list ;; to put the default at the head, then proceed with ;; default = nil. (setq collection (cons def (remove def collection)) def nil))) ;; Ready to do actual ido completion (prog1 (let ((ido-cr+-enable-next-call t)) (ido-completing-read prompt collection predicate require-match initial-input hist def inherit-input-method)) ;; This detects when the user triggered fallback mode ;; manually. (when (eq ido-exit 'fallback) (signal 'ido-cr+-fallback "user manually triggered fallback")))) ;; Handler for ido-cr+-fallback signal (ido-cr+-fallback (ido-cr+--explain-fallback sig) (apply ido-cr+-fallback-function orig-args))))) ;;;###autoload (defadvice ido-completing-read (around ido-cr+ activate) "This advice handles application of ido-completing-read+ features. First, it ensures that `ido-cr+-enable-this-call' is set properly. This variable should be non-nil during execution of `ido-completing-read' if it was called from `ido-completing-read+'. Second, if `ido-cr+-replace-completely' is non-nil, then this advice completely replaces `ido-completing-read' with `ido-completing-read+'." ;; If this advice is autoloaded, then we need to force loading of ;; the rest of the file so all the variables will be defined. (when (not (featurep 'ido-completing-read+)) (require 'ido-completing-read+)) (let ((ido-cr+-enable-this-call ido-cr+-enable-next-call) (ido-cr+-enable-next-call nil)) (if (or ido-cr+-enable-this-call ; Avoid recursion (not ido-cr+-replace-completely)) ad-do-it (message "Replacing ido-completing-read") (setq ad-return-value (apply #'ido-completing-read+ (ad-get-args 0)))))) ;; Fallback on magic C-f and C-b ;;;###autoload (defvar ido-context-switch-command nil "Variable holding the command used for switching to another completion mode. This variable is originally declared in `ido.el', but it is not given a value (or a docstring). This documentation comes from a re-declaration in `ido-completing-read+.el' that initializes it to nil, which should suppress some byte-compilation warnings in Emacs 25. Setting another package's variable is not safe in general, but in this case it should be, because ido always let-binds this variable before using it, so the initial value shouldn't matter.") (defadvice ido-magic-forward-char (before ido-cr+-fallback activate) "Allow falling back in ido-completing-read+." (when ido-cr+-enable-this-call ;; `ido-context-switch-command' is already let-bound at this ;; point. (setq ido-context-switch-command #'ido-fallback-command))) (defadvice ido-magic-backward-char (before ido-cr+-fallback activate) "Allow falling back in ido-completing-read+." (when ido-cr+-enable-this-call ;; `ido-context-switch-command' is already let-bound at this ;; point. (setq ido-context-switch-command #'ido-fallback-command))) ;;; Workaround for https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/93 (defadvice ido-select-text (around fix-require-match-behavior activate) "Fix ido behavior when `require-match' is non-nil. Standard ido will allow C-j to exit with an incomplete completion even when `require-match' is non-nil. Ordinary completion does not allow this. In ordinary completion, RET on an incomplete match is equivalent to TAB, and C-j selects the first match. Since RET in ido already selects the first match, this advice sets up C-j to be equivalent to TAB in the same situation." (if (and ;; Only override C-j behavior if... ;; We're using ico-cr+ ido-cr+-enable-this-call ;; Require-match is non-nil (with-no-warnings ido-require-match) ;; A default was provided, or ido-text is non-empty (or (with-no-warnings ido-default-item) (not (string= ido-text ""))) ;; Only if current text is not a complete choice (not (member ido-text (with-no-warnings ido-cur-list)))) (progn (ido-cr+--debug-message "Overriding C-j behavior for require-match: performing completion instead of exiting.") (ido-complete)) ad-do-it)) (provide 'ido-completing-read+) ;;; ido-completing-read+.el ends here ido-ubiquitous-3.14/ChangeLog0000644000175000017500000001652712731324552016046 0ustar dogslegdogsleg2016-06-18 Ryan C. Thompson * ido-ubiquitous.el (completing-read-ido-ubiquitous): Fix an edge case where COLLECTION is a function and PREDICATE is non-nil. This edge case caused errors in "describe-function" and "describe-variable" in Emacs 25.1. (completing-read-ido-ubiquitous): Make error handling more robust. In addition to falling back to normal completion on a specific set of expected errors, ido-ubiquitous now falls back on *any* error encountered in the body of "completing-read-ido-ubiquitous". (ido-ubiquitous-default-command-overrides): Add override for "describe-function" and "describe-variable", which now require them in Emacs 25.1. 2016-02-20 Ryan C. Thompson * ido-completing-read+.el (ido-select-text): Eliminate another compiler warning 2016-02-17 Ryan C. Thompson * test/ido-ubiquitous-test.el: Significant refactoring of awkward testing code. Tests should now be more robust. * ido-completing-read+.el (ido-select-text): Fix an edge case in ido-select-text: when require-match and default are both non-nil, it should be impossible to return an empty string. (ido-cr+-fallback-function): Don't allow ido-ubiquitous to be a fallback for ido-cr+. 2016-01-29 Ryan C. Thompson * ido-ubiquitous.el (ido-ubiquitous--maybe-update-overrides): Change default auto-update setting to notify. If the user has customized overrides and new ones are added upstream, it will nag them until they choose to explicitly enable or disable auto-updating. 2016-01-16 Rasmus * ido-ubiquitous.el (ido-ubiquitous-update-overrides): Remove dependency on s.el. 2015-11-22 Ryan C. Thompson * ido-ubiquitous.el (ido-ubiquitous--maybe-update-overrides): Allow ido-ubiquitous to automatically add new overrides. 2015-11-21 Ryan C. Thompson * ido-ubiquitous.el: Fix up dependency declarations and require statements (including a pull request by Steve Purcell) * ido-completing-read+.el (ido-select-text): Fix C-j behavior when require-match is enabled 2015-10-04 Ryan C. Thompson * ido-ubiquitous.el: Add override for etags-select 2015-06-19 Ryan C. Thompson * ido-ubiquitous.el: Fix some byte-compile warnings in autoloads by also autoloading the associated variable declarations 2015-06-18 Ryan C. Thompson * ido-ubiquitous.el: Ignore and warn about invalid overrides instead of crashing * ido-completing-read+.el: Fix some variable declaration warnings * ido-ubiquitous.el (ido-ubiquitous-default-command-overrides): Add override for "where-is" command 2015-05-28 Ryan C. Thompson * ido-ubiquitous.el (ido-ubiquitous-version): Fix a typo in the previous version 2015-04-23 Ryan C. Thompson * ido-completing-read+.el: Fix obsolete reference to "choices" instead of "collection" 2015-04-08 Ryan C. Thompson * ido-ubiquitous.el: Major refactor. Split into two packages: ido-completing-read+.el and ido-ubiquitous.el that depends on it. Additionally, some of the customization variables for ido-ubiquitous have been changed for increased flexibility in configuration, and the internals have been rearchitected significantly. 2015-01-25 Ryan C. Thompson * ido-ubiquitous: Fix indentation issues (https://github.com/DarwinAwardWinner/ido-ubiquitous/pull/62) 2014-09-04 Ryan C. Thompson * ido-ubiquitous: Enable fallbacks to non-ido-completion using C-f and C-b 2014-05-26 Ryan C. Thompson * ido-ubiquitous: Disable in tmm when called as a function as well as a command 2014-03-27 Ryan C. Thompson * ido-ubiquitous: Add override for "*-theme" functions 2014-03-24 Ryan C. Thompson * ido-ubiquitous: Fix a bug related to "ido-ubiquitous-allow-on-functional-collection" (#46) 2014-02-25 Ryan C. Thompson * ido-ubiquitous: Disable in tmm-menubar 2013-11-19 Ryan C. Thompson * ido-ubiquitous: Add new custom variable "ido-ubiquitous-allow-on-functional-collection" 2013-10-02 Ryan C. Thompson * ido-ubiquitous: Enable in "read-char-by-name" 2013-09-27 Ryan C. Thompson * ido-ubiquitous: Disable in org and magit since they already support ido 2013-09-26 Ryan C. Thompson * ido-ubiquitous: Make ido-ubiquitous work with Emacs trunk (pre-24.4) * ido-ubiquitous: Fix a few minor and unlikely-to-ever-occur bugs * ido-ubiquitous: Replace collection function whitelist with overrides (overrides can now force ido completion when collection is a function) 2013-09-23 Ryan C. Thompson * ido-ubiquitous: Implement collection function whitelist * ido-ubiquitous: Implement collection size limit for ido completion 2013-09-17 Ryan C. Thompson * ido-ubiquitous: Eliminate use of "macroexp--backtrace", which doesn't exist in Emacs 24.2. 2013-09-11 Ryan C. Thompson * ido-ubiquitous: Fix handling of collection being a function (issues #23 and #25). 2013-09-10 Ryan C. Thompson * ido-ubiquitous: Fix the issue where `called-interactively-p' always returns false https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/24 2013-09-05 Ryan C. Thompson * ido-ubiquitous: Ido-ubiquitous now works better with interactive commands. Specifically, it now works when the completion happens inside the "interactive" form of the command instead of the function body. * ido-ubiquitous: Functions and commands that need non-standard behavior are now controlled through the variables "ido-ubiquitous-command-overrides" and "ido-ubiquitous-function-overrides". * ido-ubiquitous: Major rewrite of a significant portions of ido-ubiquitous. 2013-05-31 Ryan C. Thompson * ido-ubiquitous: Officially drop support for Emacs 23 and lower. ido-ubiquitous now uses the `completing-read-function' variable instead of advising `completing-read'. * ido-ubiquitous: Make ido-ubiquitous work more reliably in interactive commands. * ido-ubiquitous: Avoid spurious warning when loaded before ido. * ido-ubiquitous: Disable ido when completion-extra-properties is non-nil * ido-ubiquitous: The interface for setting old-style completion compatibility has changed. If you have customized these settings, you should review them after upgrading. 2012-09-07 Ryan C. Thompson * ido-ubiquitous: Restore compatibility with Emacs 23 and earlier * ido-ubiquitous: Work around an ido bug where providing both an initial input and a default would break things * ido-ubiquitous: Most modifications to ido behavior are now activated only when ido is acting as a completing-read replacement, and not when it is used directly. This shoud prevent ido-ubiquitous from interfering with normal usage of ido. * ido-ubiquitous: Add Custom interface for compatibility exceptions. 2012-09-03 Ryan C. Thompson * ido-ubiquitous: New implementation: Switch from defining advice on "completing-read" to setting "completing-read-function" ido-ubiquitous-3.14/Cask0000644000175000017500000000025112731324552015063 0ustar dogslegdogsleg;; -*- mode: emacs-lisp -*- (source melpa) (package "ido-ubiquitous" "3.8" "Use ido (nearly) everywhere.") (development (depends-on "f") (depends-on "ert-runner")) ido-ubiquitous-3.14/README.md0000644000175000017500000003107112731324552015542 0ustar dogslegdogsleg# ido-ubiquitous # [![MELPA Stable](https://stable.melpa.org/packages/ido-ubiquitous-badge.svg)](https://stable.melpa.org/#/ido-ubiquitous) [![Join the chat at https://gitter.im/DarwinAwardWinner/ido-ubiquitous](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/DarwinAwardWinner/ido-ubiquitous?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) Gimme some ido... everywhere! This package replaces stock emacs completion with ido completion wherever it is possible to do so without breaking things. Get it from MELPA: https://stable.melpa.org/#/ido-ubiquitous ## Version 3.0 changes ## Long-time users should know that ido-ubiquitous version 3.0 is a major update, including a split into two packages, and some of the configuration options have changed in non-backwards-compatible ways. If you have customized any options ido-ubiquitous, be sure to check out `M-x customize-group ido-ubiquitous` and `M-x customize-group ido-completing-read+` after updating to 3.0 and make sure the new settings are to your liking. # How to enable ido in as many places as possible # If you are using this package, you probably want to enable ido everywhere that it is possible to do so. Here are all the places to enable ido that I'm aware of. (Note that most of these variables can also be set via `M-x customize-variable` if you prefer that.) ## Ido itself ## First, enable `ido-mode` and `ido-everywhere`. (ido-mode 1) (ido-everywhere 1) ## ido-ubiquitous (this package) ## Install this package [from MELPA](http://melpa.org/#/ido-ubiquitous) and then turn on `ido-ubiquitous-mode`: (require 'ido-ubiquitous) (ido-ubiquitous-mode 1) ## Smex ## Smex allows you to use ido for completion of commands in M-x, with enhancements like putting your most-used commands at the front of the list. First install the [smex](https://github.com/nonsequitur/smex) package, then follow the directions to set up key-bindings for it. ## ido-yes-or-no ## If you want to use ido for yes-or-no questions, even though it's massive overkill, install my [ido-yes-or-no package from MELPA](http://melpa.org/#/ido-yes-or-no), and then enable the mode: (require 'ido-yes-or-no) (ido-yes-or-no-mode 1) ## ido for `describe-face` and certain other commands ## Some commands, such as `describe-face`, use `completing-read-multiple` instead of `completing-read`. You can get ido completion for these commands with `crm-custom-mode`, which replaces `completing-read-multiple` with repeated calls to `completing-read`, which would then use ido thanks to ido-ubiquitous-mode. First, install the [crm-custom](https://github.com/DarwinAwardWinner/crm-custom) package [from MELPA](http://melpa.org/#/crm-custom), then enable the mode: (require 'crm-custom) (crm-custom-mode 1) Remember that when using this mode, completion for affected commands will continue to read additional items until you use C-j to enter an empty input, which terminates the completion. (Due to this quirk, I do not find this mode to be very useful in conjunction with ido, but it does work.) ## Packages with built-in ido support ## Lastly, some packages already provide their own interfaces to ido, so ido-ubiquitous specifically avoids interfering with these. If you use any of the following packages, you need to enable ido for each of them separately. * Magit: `(setq magit-completing-read-function 'magit-ido-completing-read)` * Gnus: `(setq gnus-completing-read-function 'gnus-ido-completing-read)` (You can also use `M-x customize-variable` to set all of these options.) # Frequently asked questions # ## How does ido-ubiquitous decide when to replace `completing-read`?
Why don't some commands use ido completion? ## Emacs' `completing-read` is a complex function with many advanced features and some quirks that are only maintained for backwards compatibility. Not all of these features are supported by ido, so it is impossible to always replace `completing-read` with ido completion. Trying to use ido when these features are requested can completely break the completion system. So, by default ido-ubiquitous tries to get out of the way whenever it detects that these features might be used by a given call to `completing-read`. Furthermore, it's not always possible to detect based on the arguments to `completing-read` whether such ido-incompatible features are being used or not. ido-ubiquitous uses a series of heuristics to determine whether unsupported features *might* be used, and also supports an override feature to correct it when the heuristics get things wrong. Each time a function invokes `completing-read`, ido-ubiquitous selects one of 3 modes: * `enable`: use ido completion; * `enable-old`: use ido completion, but with a compatibility fix for old-style default selection; and * `disable`: no ido completion. The following describes in detail how ido-ubiquitous selects the appropriate mode, and what to do when you think it is making the wrong choice. ### Disabling ido completion when the collection is very large ### Ido can get slow on very large collections, so by default ido-ubiquitous disables itself for collections with more than 30,000 items in them. This rule takes precedence over anything else, even overrides that explicitly enable ido completion for a command. You can change the large collection threshold by customizing `ido-cr+-max-items`. ### Disabling ido completion when the collection is a function ### One feature of `completing-read` is that the collection argument can be a function. This function could simply return a list of all possible completions, in which case it would be safe to use ido, or it could implement a completely new completion system, in which case using ido would interfere with this new completion system (for an example of this, see the `tmm` command). But ido-ubiquitous cannot tell by looking at the function which kind it is, so it errs on the side of caution and disables itself whenever the collection is a function, unless an override exists telling it that the command is safe for ido completion. You can turn off this safeguard by customizing `ido-ubiquitous-allow-on-functional-collection`. Be aware that enabling this will likely break completion entirely in any command that uses this feature to implement non-standard completion. If you run across a command that unexpectedly uses normal Emacs completion instead of ido completion, it's likely that either this or the previous option is to blame. ### Disabling or enabling ido completion by overrides ### If ido-ubiquitous is not running for a command where is should be due to the functional collection rule, you can add an override for that command by using `M-x customize-variable ido-ubiquitous-command-overrides`. Conversely, if ido completion causes problems for a command, you can also use this to disable ido-ubiquitous for that command. ## What is old-style default selection? ## The `enable-old` mode of operation is required because the old way for `completing-read` to indicate that the user simply pressed RET and selected the default option was to return an empty string. When this old-style mode is used, `completing-read` doesn't even know what the default is *supposed* to be -- the calling code handles all of that. But in ido, simply pressing RET will return the first item of the list, not an empty string. The way to enter an empty string in ido is C-j. The `enable-old` mode enables ido completion, but swaps the meaning of C-j and RET if you haven't entered any text or cycled the options yet (once you do either of those, C-j and RET regain their standard meanings). This allows you to select the default by pressing RET as soon as the completion prompt appears, as intended (C-j would select the first item). Unfortunately, there is no way for ido-ubiquitous to detect when a command is using this old-style default selection, so instead it uses a built-in set of overrides telling it about commands that are known to use old-style defaults. If you discover a command where pressing RET or C-j at an empty prompt is not doing what you expect it to, there's a good chance that you need to add an `enable-old` override for that command to `ido-ubiquitous-command-overrides`. Luckily, since this is an obsolete usage pattern, it is unlikely that any Elisp functions written since 1990 or so will need to be added to this list. Hopefully all uses of old-style completion will eventually be eliminated, and with them, the need for this feature of ido-ubiquitous. ## How can I troubleshoot when ido-ubiquitous isn't doing what I want? ## First, invoke the `ido-ubiquitous-debug-mode` and `ido-cr+-debug-mode` commands. Then, with these two modes active, run the command(s) that you are having trouble with, and when the completion prompt appears, make a selection to complete the process. Then, examine the Messages buffer, where ido-ubiquitous will explain which mode of operation it selected and why. Based on this, you can add an override to `ido-ubiquitous-command-overrides`. If you are not familiar with the structure of this variable, I recommend using `M-x customize-variable` to edit it, which will help you get it right. If ido completion was skipped ido completion because the collection was too large, try giving `ico-cr+-max-items` a larger value, or set it to nil if your computer is fast enough to handle any size of collection. Updates to ido-ubiquitous often include new overrides, but Emacs will not edit your override variables if you have already customized them. So, if you have recently upgraded ido-ubiquitous, remember to invoke `ido-ubiquitous-restore-default-overrides` to add in any new overrides. (In the future, this process may become automatic: https://github.com/DarwinAwardWinner/ido-ubiquitous/issues/90) ## Where can I report bugs or suggest new overrides? ## If you end up adding any overrides, please also report them at https://github.com/DarwinAwardWinner/ido-ubiquitous/issues so I can incorporate them into the defaults for future versions. You can also report any bugs you find in ido-ubiquitous. ## I'm getting some weird warnings from ido-ubiquitous when Emacs starts. ## I've gotten numerous reports about nonsensical warnings produced by ido-ubiquitous, such as "free variable" warnings about variables that are most definitely properly declared, or warnings that only appear when ido-ubiquitous is loaded after another unrelated package. For many of these warnings, I've never been able to discover the cause or reproduce the warnings myself, and I've given up trying to figure it out. Please don't report any new bugs about variable warnings *unless* you can tell me how to consistently reproduce them starting from `emacs -Q`. If you are an Emacs expert who knows how to fix these warnings, please let me know. You can see the bug reports about weird warnings [here](https://github.com/DarwinAwardWinner/ido-ubiquitous/issues?utf8=%E2%9C%93&q=label%3Abizarre-unexplainable-scoping-issues+). ## What is the "bleeding-edge" branch? ## All users should just use the master branch, or better yet, install from MELPA. The bleeding-edge branch is where I test experimental and unfinished features. Because ido-ubiquitous hooks deeply into the bowels of Emacs, a bug in ido-ubiquitous could easily freeze or crash Emacs entirely. Additionally, some bug only show up when ido-ubiquitous is installed and compiled as a package. So I test every new feature myself for some time on this branch before pushing to the master branch. If you report a bug, I might develop a fix for it on the bleeding edge branch and ask then you to try this branch. Otherwise, normal users don't need to think about this branch. # ido-completing-read+ # As of version 3.0, most of the core functionality of ido-ubiquitous has been spun off into a separate library called ido-completing-read+, or "ido-cr+" for short. ido-cr+ incorporates all the features of ido-ubiquitous that are actually just generic improvements to ido that should probably always be enabled. It implements these fixes in a single function `ido-completing-read+`, which should be suitable as a drop-in replacement for either `ido-completing-read` or `completing-read`. Notably, unlike the original `ido-completing-read`, `ido-completing-read+` should always do something useful, by falling back to normal completion when ido completion won't work. Additionally, it allows you to manually fall back using C-f and C-b, in the same way you can use those keys to switch between file and buffer completion in ido. As a user, you don't really need to know anything about ido-cr+. However, if you are writing an Emacs package and would like to incorporate ido completion, you may wish to use ido-cr+ to get more robust completion with fewer weird edge cases. ido-ubiquitous-3.14/setversion.sh0000755000175000017500000000071012731324552017017 0ustar dogslegdogsleg#!/bin/bash TARGET_VERSION="$1" if [ -n "$TARGET_VERSION" ]; then echo "Updating version to $TARGET_VERSION"; perl -i'orig_*' -lape "s/Version: [0-9.]+/Version: $TARGET_VERSION/g;" \ -e "s/((?:defconst|defvar|setq).*-version\s+)\"[0-9.]+\"/\${1}\"$TARGET_VERSION\"/g;" \ -e "s/(Package-Requires.*\(ido-completing-read\+\s+)\"[0-9.]+\"\)/\${1}\"${TARGET_VERSION}\")/g;" \ *.el else echo "Usage: $0 VERSION_NUMBER" fi ido-ubiquitous-3.14/.gitignore0000644000175000017500000000000712731324552016246 0ustar dogslegdogsleg/.cask ido-ubiquitous-3.14/test/0000755000175000017500000000000012731324552015240 5ustar dogslegdogslegido-ubiquitous-3.14/test/ido-ubiquitous-test.el0000644000175000017500000005126012731324552021525 0ustar dogslegdogsleg;;; ido-ubiquitous-test.el --- -*- lexical-binding: t -*- ;; Copyright (C) 2015 Ryan C. Thompson ;; Filename: ido-ubiquitous-test.el ;; Author: Ryan C. Thompson ;; Created: Tue Oct 6 20:52:45 2015 (-0700) ;; This file is NOT part of GNU Emacs. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; 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 GNU Emacs. If not, see . ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Code: (require 'ido-completing-read+) (require 'ido-ubiquitous) (require 'ert) (require 'cl-lib) ;; This is a series of macros to facilitate the testing of completion ;; non-interactively by simulating input. (defmacro keyboard-quit-to-error (&rest body) "Evaluate BODY but signal an error on `keyboard-quit'." `(condition-case nil (progn ,@body) (quit (error "Caught `keyboard-quit'")))) (defmacro with-simulated-input (keys &rest body) "Eval body with KEYS as simulated input. This macro is intended for testing normally interactive functions by simulating input. If BODY tries to read more input events than KEYS provides, `keyboard-quit' is invoked (by means of appending multple C-g keys to KEYS). This is to ensure that BODY will never block waiting for input, since this macro is intended for noninteractive use. As such, BODY should not invoke `keyboard-quit' under normal operation, and KEYS should not include C-g, or this macro will interpret it as reading past the end of input." ;; It would be better to detect end-of-input by overriding ;; `read-event' to throw an error, since theoretically C-g could be ;; rebound to something other than `keyboard-quit'. But apparently ;; some functions read input directly in C code, and redefining ;; `read-event' has no effect on those. So the suboptimal solution ;; is to rely on C-g. (declare (indent 1)) `(let* ((key-sequence (listify-key-sequence (kbd ,keys))) (C-g-key-sequence (listify-key-sequence ;; We *really* want to trigger `keyboard-quit' if we reach ;; the end of the input. (kbd "C-g C-g C-g C-g C-g C-g C-g"))) (unread-command-events (append key-sequence C-g-key-sequence))) (when (member (car C-g-key-sequence) key-sequence) (error "KEYS must not include C-g")) (condition-case nil (progn ,@body) (quit (error "Reached end of simulated input while evaluating body"))))) (defmacro with-mode (mode arg &rest body) "Eval (MODE ARG), then body, then restore previous status of MODE. This will only work on modes that respect the normal conventions for activation and deactivation." (declare (indent 2)) `(let* ((orig-status ,mode) (restore-arg (if orig-status 1 0))) (unwind-protect (progn (,mode ,arg) ,@body) (message "Restoring mode %s to %s" ',mode restore-arg) (,mode restore-arg)))) (defmacro with-ido-ubiquitous-standard-env (&rest body) "Execute BODY with standard ido-ubiquitous settings.\n\nAll ido-ubiquitous and ido-cr+ options will be let-bound to their\ndefault values, and `ido-ubiquitous-mode' will be enabled." (declare (indent 0)) (let* ((ido-ubiquitous-options '(ido-ubiquitous-allow-on-functional-collection ido-ubiquitous-command-overrides ido-ubiquitous-debug-mode ido-ubiquitous-default-state ido-ubiquitous-function-overrides ido-cr+-fallback-function ido-cr+-max-items ido-cr+-replace-completely)) (idu-bindings (cl-loop for var in ido-ubiquitous-options collect (list var (list 'quote (eval (car (get var 'standard-value)))))))) `(with-mode ido-ubiquitous-mode 1 (let ,idu-bindings ,@body)))) (defmacro collection-as-function (collection) "Return a function equivalent to COLLECTION. The returned function will work equivalently to COLLECTION when passed to `all-completions' and `try-completion'." `(completion-table-dynamic (lambda (string) (all-completions string ,collection)))) (cl-defmacro should-with-tag (form &key tag) "Equivalent to `(should FORM)' but with a TAG on the output. This is useful if the same `should' form will be called multiple times in different contexts. Each test can pass a different tag so it's clear in the ERT output which context is causing the failure. Note that although this is a macro, the TAG argument is evaluated normally." `(let ((tagvalue ,tag)) (condition-case err (should ,form) (ert-test-failed (message "Error symbol: %S" (car err)) (message "Error data: %S" (cdr err)) (when tagvalue (setf (cadr err) (append (cadr err) (list :tag tagvalue)))) (message "New error data: %S" (cdr err)) (signal (car err) (cdr err)))))) (defun plist-delete (plist property) "Delete PROPERTY from PLIST. This is in contrast to merely setting it to 0." (let (p) (while plist (if (not (eq property (car plist))) (setq p (plist-put p (car plist) (nth 1 plist)))) (setq plist (cddr plist))) p)) (cl-defmacro should-error-with-tag (form &rest other-keys &key tag &allow-other-keys) "Equivalent to `(should FORM)' but with a TAG on the output. See `should-with-tag'. Note that although this is a macro, the TAG argument is evaluated normally." (setq other-keys (plist-delete other-keys :tag)) `(let ((tagvalue ,tag)) (condition-case err (should-error ,form ,@other-keys) (ert-test-failed (message "Error symbol: %S" (car err)) (message "Error data: %S" (cdr err)) (when tagvalue (setf (cadr err) (append (cadr err) (list :tag tagvalue)))) (message "New error data: %S" (cdr err)) (signal (car err) (cdr err)))))) (defun test-ido-ubiquitous-expected-mode (override &optional tag) "Test whether observed ido-ubiquitous behavior matches OVERRIDE." (declare (indent 1)) (if (eq override 'disable) (progn (should-with-tag ;; Verify that we get standard completion (string= "g" (with-simulated-input "g RET" (completing-read "Prompt: " '("blue" "yellow" "green")))) :tag tag) (should-with-tag (string= "green" (with-simulated-input "g RET" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag) ;; Standard completion should refuse to finish with incomplete ;; input if match is required (should-error-with-tag (with-simulated-input "b RET" (completing-read "Prompt: " '("brown" "blue" "yellow" "green") nil t)) :type 'error :tag tag)) ;; Common tests whenever ido-ubiquitous is enabled in any way (should-with-tag ;; Verify that ido completion is active (string= "green" (with-simulated-input "g RET" (completing-read "Prompt: " '("blue" "yellow" "green")))) :tag tag) ;; Verify that C-j is working correctly (should-with-tag (string= "g" (with-simulated-input "g C-j" (completing-read "Prompt: " '("blue" "yellow" "green")))) :tag tag) (let ((collection '("brown" "blue" "yellow" "green"))) (should-with-tag (member (with-simulated-input "b RET" (completing-read "Prompt: " collection)) (all-completions "b" collection)) :tag tag)) (case override (enable ;; Test for new style (should-with-tag (string= "blue" (with-simulated-input "RET" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag) (should-with-tag (string= "" (with-simulated-input "C-j" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag)) (enable-old (should-with-tag (string= "" (with-simulated-input "RET" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag) (should-with-tag (string= "blue" (with-simulated-input "C-j" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag) ;; Verify that doing other stuff reverts RET and C-j to standard ;; meanings (should-with-tag (string= "blue" (with-simulated-input "g DEL RET" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag) (should-with-tag (string= "blue" (with-simulated-input " RET" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag) (should-with-tag (string= "" (with-simulated-input "g DEL C-j" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag) (should-with-tag (string= "" (with-simulated-input " C-j" (completing-read "Prompt: " '("blue" "yellow" "green") nil t))) :tag tag)) (otherwise (error "Unknown override %S" override))))) (defvar original-completing-read (symbol-function #'completing-read)) (defun test-ido-ubiquitous-expected-mode-on-functional-collection (override &optional tag) "Test whether observed ido-ubiquitous behavior on functional collection matches OVERRIDE." (declare (indent 1)) ;; This just temporarily replaces `completing-read' with a wrapper ;; that always converts the collection argument to an equivalent ;; function. That way, any use of `completing-read' will always see ;; a functional collection. (cl-letf (((symbol-function 'completing-read) (lambda (prompt collection &rest args) (apply original-completing-read prompt (collection-as-function collection) args)))) (test-ido-ubiquitous-expected-mode override tag))) (ert-deftest ido-ubiquitous-test-simple () :tags '(ido ido-ubiquitous) "Test that basic ido-ubiquitous functionality is working." (with-ido-ubiquitous-standard-env (ido-ubiquitous-mode 1) (test-ido-ubiquitous-expected-mode 'enable :simple-enable) (ido-ubiquitous-mode 0) (test-ido-ubiquitous-expected-mode 'disable :simple-disable))) (ert-deftest ido-ubiquitous-test-oldstyle () :tags '(ido ido-ubiquitous) "Test whether old-style completion works as expected." (with-ido-ubiquitous-standard-env (let ((ido-ubiquitous-default-state 'enable-old)) (test-ido-ubiquitous-expected-mode 'enable-old :simple-oldstyle)))) (ert-deftest ido-ubiquitous-test-maxitems () :tags '(ido ido-ubiquitous) "Test whether the large-collection fallback works." (with-ido-ubiquitous-standard-env (let ((ido-cr+-max-items -1)) (test-ido-ubiquitous-expected-mode 'disable :maxitems)))) (ert-deftest ido-ubiquitous-test-override () :tags '(ido ido-ubiquitous) "Test whether ido-ubiquitous overrides work." (with-ido-ubiquitous-standard-env (ido-ubiquitous-with-override 'enable (test-ido-ubiquitous-expected-mode 'enable :override-enable)) (ido-ubiquitous-with-override 'enable-old (test-ido-ubiquitous-expected-mode 'enable-old :override-enable-old)) (ido-ubiquitous-with-override 'disable (test-ido-ubiquitous-expected-mode 'disable :override-disable)))) (ert-deftest ido-ubiquitous-test-functional-collection () :tags '(ido ido-ubiquitous) "Test whether ido-ubiquitous overrides work when collection is a function." (with-ido-ubiquitous-standard-env (test-ido-ubiquitous-expected-mode-on-functional-collection 'disable :collfunc) (ido-ubiquitous-with-override 'enable (test-ido-ubiquitous-expected-mode-on-functional-collection 'enable :override-enable-collfunc)) (ido-ubiquitous-with-override 'enable-old (test-ido-ubiquitous-expected-mode-on-functional-collection 'enable-old :override-enable-old-collfunc)))) (ert-deftest ido-cr+-require-match () :tags '(ido ido-cr+) "Test whether require-match works." ;; "C-j" should be allowed to return an empty string even if ;; require-match is non-nil, as long as default is nil (should (string= "" (with-simulated-input "C-j" (ido-completing-read+ "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t)))) ;; "C-j" should NOT be allowed to return an empty string if ;; require-match and default are both non-nil. (should-error (with-simulated-input "C-j" (ido-completing-read+ "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t nil nil "yellow"))) ;; Multiple presses of C-j won't just select the first match (should-error (with-simulated-input "b C-j C-j C-j" (ido-completing-read+ "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t))) ;; First press of C-j should complete unique common prefix after the ;; first b, but then get stuck on the choice for the second b. (should-error (with-simulated-input "b C-j b C-j C-j" (ido-completing-read+ "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t))) ;; This should complete to "blueberry" via 2 rounds of unique common ;; prefix completion, and then return on the 3rd "C-j" (should (string= "blueberry" (with-simulated-input "b C-j b C-j e C-j C-j" (ido-completing-read+ "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t)))) ;; The "C-j" should complete to "bluegrass" but should ;; not return. (should-error (with-simulated-input "b l u e g C-j" (ido-completing-read+ "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t))) ;; The first "C-j" should complete to "bluegrass", and the second ;; should return. (should (string= "bluegrass" (with-simulated-input "b l u e g C-j C-j" (ido-completing-read+ "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t)))) ;; Finally, a few tests for the expected wrong behavior without ;; ido-cr+. If ido.el ever fixes this bug, it will cause this test ;; to fail as a signal that the workaround can be phased out. (should (string= "" (with-simulated-input "C-j" (ido-completing-read "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t)))) (should (string= "b" (with-simulated-input "b C-j" (ido-completing-read "Prompt: " '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t))))) ;; Functions to define overrides on for testing (defun idu-no-override-testfunc () (test-ido-ubiquitous-expected-mode 'enable :func-override-none) (test-ido-ubiquitous-expected-mode-on-functional-collection 'disable :func-override-none-collfunc)) (defun idu-enabled-testfunc (&rest args) (test-ido-ubiquitous-expected-mode 'enable :func-override-enable) (test-ido-ubiquitous-expected-mode-on-functional-collection 'enable :func-override-enable-collfunc)) (defun idu-disabled-testfunc (&rest args) (test-ido-ubiquitous-expected-mode 'disable :func-override-disable) (test-ido-ubiquitous-expected-mode-on-functional-collection 'disable :func-override-disable-collfunc)) (defun idu-enabled-oldstyle-testfunc (&rest args) (test-ido-ubiquitous-expected-mode 'enable-old :func-override-enable-old) (test-ido-ubiquitous-expected-mode-on-functional-collection 'enable-old :func-override-enable-old-collfunc)) ;; commands to define overrides on for testing (defun idu-no-override-testcmd (&rest args) (interactive (list (test-ido-ubiquitous-expected-mode 'enable :cmd-override-none) (test-ido-ubiquitous-expected-mode-on-functional-collection 'disable :cmd-override-none-collfunc))) (test-ido-ubiquitous-expected-mode 'enable :cmd-override-none) (test-ido-ubiquitous-expected-mode-on-functional-collection 'disable :cmd-override-non-collfunc)) (defun idu-enabled-testcmd (&rest args) (interactive (list (test-ido-ubiquitous-expected-mode 'enable :cmd-override-enable) (test-ido-ubiquitous-expected-mode-on-functional-collection 'enable :cmd-override-enable-collfunc))) (test-ido-ubiquitous-expected-mode 'enable :cmd-override-enable) (test-ido-ubiquitous-expected-mode-on-functional-collection 'enable :cmd-override-enable-collfunc)) (defun idu-disabled-testcmd (&rest args) (interactive (list (test-ido-ubiquitous-expected-mode 'disable :cmd-override-disable) (test-ido-ubiquitous-expected-mode-on-functional-collection 'disable :cmd-override-disable-collfunc))) (test-ido-ubiquitous-expected-mode 'disable :cmd-override-disable) (test-ido-ubiquitous-expected-mode-on-functional-collection 'disable :cmd-override-disable-collfunc)) (defun idu-enabled-oldstyle-testcmd (&rest args) (interactive (list (test-ido-ubiquitous-expected-mode 'enable-old :cmd-override-enable-old) (test-ido-ubiquitous-expected-mode-on-functional-collection 'enable-old :cmd-override-enable-old-collfunc))) (test-ido-ubiquitous-expected-mode 'enable-old :cmd-override-enable-old) (test-ido-ubiquitous-expected-mode-on-functional-collection 'enable-old :cmd-override-enable-old-collfunc)) (ert-deftest ido-ubiquitous-test-command-and-function-overrides () :tags '(ido ido-ubiquitous) "Test whether command- and function-specific overrides work." (let ((orig-func-overrides ido-ubiquitous-function-overrides) (orig-cmd-overrides ido-ubiquitous-command-overrides)) (unwind-protect (with-ido-ubiquitous-standard-env (customize-set-variable 'ido-ubiquitous-function-overrides (append ido-ubiquitous-function-overrides '((enable exact "idu-enabled-testfunc") (disable exact "idu-disabled-testfunc") (enable-old exact "idu-enabled-oldstyle-testfunc")))) (cl-loop for func in '(idu-no-override-testfunc idu-enabled-testfunc idu-disabled-testfunc idu-enabled-oldstyle-testfunc) do (funcall func)) (customize-set-variable 'ido-ubiquitous-command-overrides (append ido-ubiquitous-command-overrides '((enable exact "idu-enabled-testcmd") (disable exact "idu-disabled-testcmd") (enable-old exact "idu-enabled-oldstyle-testcmd")))) (cl-loop for cmd in '(idu-no-override-testcmd idu-enabled-testcmd idu-disabled-testcmd idu-enabled-oldstyle-testcmd) do (call-interactively cmd))) (customize-set-variable 'ido-ubiquitous-function-overrides orig-func-overrides) (customize-set-variable 'ido-ubiquitous-command-overrides orig-cmd-overrides)))) (ert-deftest ido-ubiquitous-test-fallback () :tags '(ido ido-ubiquitous) "Test whether manually invoking fallback works." (with-ido-ubiquitous-standard-env (should ;; C-b/f not at beginning/end of input should not fall back (string= "green" (with-simulated-input "g C-b C-f RET" (completing-read "Prompt: " '("blue" "yellow" "green"))))) (should ;; C-f at end of input should fall back (string= "g" (with-simulated-input "g C-f RET" (completing-read "Prompt: " '("blue" "yellow" "green"))))) (should ;; Repeated C-b should not fall back (string= "green" (with-simulated-input "g C-b C-b C-b C-b RET" (completing-read "Prompt: " '("blue" "yellow" "green"))))) (should ;; C-b at beginning of line should fall back (if previous action ;; was not also C-b) (string= "g" (with-simulated-input "g C-b x DEL C-b RET" (completing-read "Prompt: " '("blue" "yellow" "green"))))))) (defun ido-ubiquitous-run-all-tests () (interactive) (ert "^ido-\\(ubiquitous\\|cr\\+\\)-")) (provide 'ido-ubiquitous-test) ;;; ido-ubiquitous-test.el ends here ido-ubiquitous-3.14/test/test-helper.el0000644000175000017500000000266012731324552020022 0ustar dogslegdogsleg;;; test-helper.el --- -*- lexical-binding: t -*- ;; Copyright (C) 2015 Ryan C. Thompson ;; Filename: test-helper.el ;; Author: Ryan C. Thompson ;; Created: Sat Nov 21 15:27:00 2015 (-0800) ;; Version: ;; Package-Requires: () ;; URL: ;; Keywords: ;; This file is NOT part of GNU Emacs. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Commentary: ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; 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 GNU Emacs. If not, see . ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Code: (require 'f) (defvar test-path (f-dirname (f-this-file))) (defvar code-path (f-parent test-path)) (add-to-list 'load-path code-path) (require 'ido-completing-read+) (require 'ido-ubiquitous) (provide 'test-helper) ;;; test-helper.el ends here