:group 'ido)
(defcustom ido-ignore-extensions t
- "*Non-nil means ignore files in completion-ignored-extensions list."
+ "*Non-nil means ignore files in `completion-ignored-extensions' list."
:type 'boolean
:group 'ido)
(defcustom ido-show-dot-for-dired nil
"*Non-nil means to always put . as the first item in file name lists.
-This allows the current directory to be opened immediate with `dired'."
+This allows the current directory to be opened immediately with `dired'."
:type 'boolean
:group 'ido)
(defcustom ido-enable-prefix nil
"*Non-nil means only match if the entered text is a prefix of file name.
This behavior is like the standard emacs-completion.
-Nil means to match if the entered text is an arbitrary substring.
+nil means to match if the entered text is an arbitrary substring.
Value can be toggled within `ido' using `ido-toggle-prefix'."
:type 'boolean
:group 'ido)
(defcustom ido-max-dir-file-cache 100
"*Maximum number of working directories to be cached.
-This is the size of the cache of file-name-all-completions results.
+This is the size of the cache of `file-name-all-completions' results.
Each cache entry is time stamped with the modification time of the
directory. Some systems, like Windows, have unreliable directory
modification times, so you may choose to disable caching on such
"*List of strings used by ido to display the alternatives in the minibuffer.
There are 10 elements in this list:
1st and 2nd elements are used as brackets around the prospect list,
-3rd element is the separator between prospects (ignored if ido-separator is set),
+3rd element is the separator between prospects (ignored if `ido-separator' is set),
4th element is the string inserted at the end of a truncated list of prospects,
5th and 6th elements are used as brackets around the common match string which
can be completed using TAB,
:group 'ido)
(defface ido-first-match '((t (:bold t)))
- "*Font used by ido for highlighting first match."
+ "*Face used by ido for highlighting first match."
:group 'ido)
(defface ido-only-match '((((class color))
(:foreground "ForestGreen"))
(t (:italic t)))
- "*Font used by ido for highlighting only match."
+ "*Face used by ido for highlighting only match."
:group 'ido)
(defface ido-subdir '((((min-colors 88) (class color))
(((class color))
(:foreground "red"))
(t (:underline t)))
- "*Font used by ido for highlighting subdirs in the alternatives."
+ "*Face used by ido for highlighting subdirs in the alternatives."
:group 'ido)
(defface ido-indicator '((((min-colors 88) (class color))
:background "red"
:width condensed))
(t (:inverse-video t)))
- "*Font used by ido for highlighting its indicators."
+ "*Face used by ido for highlighting its indicators."
:group 'ido)
(defface ido-incomplete-regexp
prefix - either nil or a fixed prefix for the dirname
The following variables are available, but should not be changed:
- ido-current-directory - the unabbreviated directory name
+ `ido-current-directory' - the unabbreviated directory name
item - equals `file' or `dir' depending on the current mode."
:type 'hook
:group 'ido)
(defvar ido-use-mycompletion-depth 0
"Non-nil means use `ido' completion feedback.
-Is set by ido functions to the current minibuffer-depth, so that
-it doesn't interfere with other minibuffer usage.")
+Is set by ido functions to the current `minibuffer-depth',
+so that it doesn't interfere with other minibuffer usage.")
(defvar ido-incomplete-regexp nil
"Non-nil if an incomplete regexp is entered.")
(and d (cdr d)))))))
(if (member ido-default-item ido-ignore-item-temp-list)
(setq ido-default-item nil))
+ (ido-trace "new default" ido-default-item)
(setq ido-set-default-item nil))
(if ido-process-ignore-lists-inhibit
(not (if ido-directory-too-big
(file-exists-p (concat ido-current-directory ido-final-text))
(ido-existing-item-p))))
- (error "must specify valid item"))
+ (error "Must specify valid item"))
(t
(setq ido-selected
(defun ido-edit-input ()
"Edit absolute file name entered so far with ido; terminate by RET."
(interactive)
- (setq ido-text-init (if ido-matches (car ido-matches) ido-text))
+ (setq ido-text-init (if ido-matches (ido-name (car ido-matches)) ido-text))
(setq ido-exit 'edit)
(exit-minibuffer))
;; buffer doesn't exist
((eq ido-create-new-buffer 'never)
- (message "no buffer matching `%s'" buf))
+ (message "No buffer matching `%s'" buf))
((and (eq ido-create-new-buffer 'prompt)
(not (y-or-n-p (format "No buffer matching `%s', create one? " buf))))
(let ((ido-current-directory (ido-expand-directory default))
(ido-context-switch-command switch-cmd)
ido-directory-nonreadable ido-directory-too-big
- (minibuffer-completing-file-name t)
filename)
(if (or (not ido-mode) (ido-is-slow-ftp-host))
(unless filename
(setq ido-saved-vc-hb vc-handled-backends)
- (setq filename (ido-read-internal item
- (or prompt "Find file: ")
- 'ido-file-history nil nil initial)))
+ (let ((minibuffer-completing-file-name t))
+ (setq filename (ido-read-internal item
+ (or prompt "Find file: ")
+ 'ido-file-history nil nil initial))))
;; Choose the file name: either the text typed in, or the head
;; of the list of matches
((and (= 1 (length ido-matches))
(not (and ido-enable-tramp-completion
(string-equal ido-current-directory "/")
- (string-match "..[@:]\\'" (car ido-matches)))))
+ (string-match "..[@:]\\'" (ido-name (car ido-matches))))))
;; only one choice, so select it.
(if (not ido-confirm-unique-completion)
(exit-minibuffer)
(setq ido-rescan (not ido-enable-prefix))
(delete-region (minibuffer-prompt-end) (point))
- (insert (car ido-matches))))
+ (insert (ido-name (car ido-matches)))))
(t ;; else there could be some completions
(setq res ido-common-match-string)
(defun ido-magic-backward-char ()
"Move backward in user input or perform magic action.
If no user input is present, or at start of input, perform magic actions:
-C-x C-f C-b switch to ido-switch-buffer.
-C-x C-d C-b switch to ido-switch-buffer.
-C-x d C-b switch to ido-switch-buffer.
-C-x C-b C-b fallback to non-ido switch-to-buffer."
+C-x C-f C-b switch to `ido-switch-buffer'.
+C-x C-d C-b switch to `ido-switch-buffer'.
+C-x d C-b switch to `ido-switch-buffer'.
+C-x C-b C-b fallback to non-ido `switch-to-buffer'."
(interactive)
(cond
((> (point) (minibuffer-prompt-end))
May be useful if cached version is no longer valid, but directory
timestamp has not changed (e.g. with ftp or on Windows)."
(interactive)
- (if (and ido-mode (eq ido-cur-item 'file))
+ (if (and ido-mode (memq ido-cur-item '(file dir)))
(progn
(if (ido-is-unc-root)
(setq ido-unc-hosts-cache t)
(exit-minibuffer))
(defun ido-enter-dired ()
- "Drop into dired from file switching."
+ "Drop into `dired' from file switching."
(interactive)
(setq ido-exit 'dired)
(exit-minibuffer))
(defun ido-enter-insert-buffer ()
- "Drop into insert buffer from insert file."
+ "Drop into `insert-buffer' from insert file."
(interactive)
(setq ido-exit 'insert-buffer)
(exit-minibuffer))
(defun ido-enter-insert-file ()
- "Drop into insert file from insert buffer."
+ "Drop into `insert-file' from insert buffer."
(interactive)
(setq ido-exit 'insert-file)
(exit-minibuffer))
"Use first matching item as input text."
(interactive)
(when ido-matches
- (setq ido-text-init (car ido-matches))
+ (setq ido-text-init (ido-name (car ido-matches)))
(setq ido-exit 'refresh)
(exit-minibuffer)))
"Move to previous directory in file name, push first match on stack."
(interactive)
(if ido-matches
- (setq ido-text (car ido-matches)))
+ (setq ido-text (ido-name (car ido-matches))))
(setq ido-exit 'push)
(exit-minibuffer))
"Insert file name of current buffer.
If repeated, insert text from buffer instead."
(interactive "P")
- (let* ((bfname (buffer-file-name ido-entry-buffer))
+ (let* ((bfname (or (buffer-file-name ido-entry-buffer)
+ (buffer-name ido-entry-buffer)))
(name (and bfname (file-name-nondirectory bfname))))
(when name
(setq ido-text-init
(let ((oa (ido-file-extension-order a n))
(ob (ido-file-extension-order b n)))
(cond
- ((= oa ob)
- lessp)
((and oa ob)
- (if lessp
- (> oa ob)
- (< oa ob)))
+ (cond
+ ((= oa ob)
+ lessp)
+ (lessp
+ (> oa ob))
+ (t
+ (< oa ob))))
(oa
(not lessp))
(ob
(let ((filenames
(split-string
(shell-command-to-string
- (concat "find " dir " -name \"" (if prefix "" "*") file "*\" -type " (if finddir "d" "f") " -print"))))
+ (concat "find "
+ (shell-quote-argument dir)
+ " -name "
+ (shell-quote-argument
+ (concat (if prefix "" "*") file "*"))
+ " -type " (if finddir "d" "f") " -print"))))
filename d f
res)
(while filenames
(let* ((case-fold-search ido-case-fold)
(slash (and (not ido-enable-prefix) (ido-final-slash ido-text)))
(text (if slash (substring ido-text 0 -1) ido-text))
- (rexq (concat (if ido-enable-regexp text (regexp-quote text)) (if slash ".*/" "")))
+ (rex0 (if ido-enable-regexp text (regexp-quote text)))
+ (rexq (concat rex0 (if slash ".*/" "")))
(re (if ido-enable-prefix (concat "\\`" rexq) rexq))
- (full-re (and do-full (not ido-enable-regexp) (not (string-match "\$\\'" re))
- (concat "\\`" re "\\'")))
+ (full-re (and do-full (not ido-enable-regexp) (not (string-match "\$\\'" rex0))
+ (concat "\\`" rex0 (if slash "/" "") "\\'")))
+ (suffix-re (and do-full slash
+ (not ido-enable-regexp) (not (string-match "\$\\'" rex0))
+ (concat rex0 "/\\'")))
(prefix-re (and full-re (not ido-enable-prefix)
(concat "\\`" rexq)))
(non-prefix-dot (or (not ido-enable-dot-prefix)
(not ido-process-ignore-lists)
ido-enable-prefix
(= (length ido-text) 0)))
-
- full-matches
- prefix-matches
- matches)
+ full-matches suffix-matches prefix-matches matches)
(setq ido-incomplete-regexp nil)
(condition-case error
(mapcar
(lambda (item)
(let ((name (ido-name item)))
- (if (and (or non-prefix-dot
- (if (= (aref ido-text 0) ?.)
- (= (aref name 0) ?.)
- (/= (aref name 0) ?.)))
- (string-match re name))
- (cond
- ((and full-re (string-match full-re name))
- (setq full-matches (cons item full-matches)))
- ((and prefix-re (string-match prefix-re name))
- (setq prefix-matches (cons item prefix-matches)))
- (t (setq matches (cons item matches))))))
- t)
+ (if (and (or non-prefix-dot
+ (if (= (aref ido-text 0) ?.)
+ (= (aref name 0) ?.)
+ (/= (aref name 0) ?.)))
+ (string-match re name))
+ (cond
+ ((and full-re (string-match full-re name))
+ (setq full-matches (cons item full-matches)))
+ ((and suffix-re (string-match suffix-re name))
+ (setq suffix-matches (cons item suffix-matches)))
+ ((and prefix-re (string-match prefix-re name))
+ (setq prefix-matches (cons item prefix-matches)))
+ (t (setq matches (cons item matches))))))
+ t)
items)
(invalid-regexp
(setq ido-incomplete-regexp t
;; special-case single match, and handle appropriately
;; elsewhere.
matches (cdr error))))
- (if prefix-matches
- (setq matches (nconc prefix-matches matches)))
- (if full-matches
- (setq matches (nconc full-matches matches)))
+ (when prefix-matches
+ (ido-trace "prefix match" prefix-matches)
+ (setq matches (nconc prefix-matches matches)))
+ (when suffix-matches
+ (ido-trace "suffix match" (list text suffix-re suffix-matches))
+ (setq matches (nconc suffix-matches matches)))
+ (when full-matches
+ (ido-trace "full match" (list text full-re full-matches))
+ (setq matches (nconc full-matches matches)))
(when (and (null matches)
ido-enable-flex-matching
(> (length ido-text) 1)
((stringp nextstr)
(and (>= flen (setq slen (length nextstr)))
(string-equal (substring name (- flen slen)) nextstr)))
- ((fboundp nextstr) (funcall nextstr name))
+ ((functionp nextstr) (funcall nextstr name))
(t nil))
(setq ignorep t
ext-list nil
(setq nextstr (car re-list))
(if (cond
((stringp nextstr) (string-match nextstr name))
- ((fboundp nextstr) (funcall nextstr name))
+ ((functionp nextstr) (funcall nextstr name))
(t nil))
(setq ignorep t
re-list nil)
(funcall f completion-list
:help-string "ido "
:activate-callback
- '(lambda (x y z) (message "doesn't work yet, sorry!"))))
+ '(lambda (x y z) (message "Doesn't work yet, sorry!"))))
;; else running Emacs
;;(add-hook 'completion-setup-hook 'completion-setup-function)
(display-completion-list completion-list)))))))
"Kill the buffer at the head of `ido-matches'."
(interactive)
(let ((enable-recursive-minibuffers t)
- (buf (car ido-matches)))
+ (buf (ido-name (car ido-matches))))
(when buf
(kill-buffer buf)
;; Check if buffer still exists.
"Delete the file at the head of `ido-matches'."
(interactive)
(let ((enable-recursive-minibuffers t)
- (file (car ido-matches)))
+ (file (ido-name (car ido-matches))))
(if file
(setq file (concat ido-current-directory file)))
(when (and file
(defun ido-visit-buffer (buffer method &optional record)
"Switch to BUFFER according to METHOD.
Record command in `command-history' if optional RECORD is non-nil."
-
+ (if (bufferp buffer)
+ (setq buffer (buffer-name buffer)))
(let (win newframe)
(cond
((eq method 'kill)
;;;###autoload
(defun ido-dired ()
- "Call dired the ido way.
+ "Call `dired' the ido way.
The directory is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido-find-file'."
(interactive)
(ido-file-internal 'dired 'dired nil "Dired: " 'dir)))
(defun ido-list-directory ()
- "Call list-directory the ido way.
+ "Call `list-directory' the ido way.
The directory is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido-find-file'."
(interactive)
try-single-dir-match
refresh)
- (ido-trace "\nexhibit" this-command)
- (ido-trace "dir" ido-current-directory)
- (ido-trace "contents" contents)
- (ido-trace "list" ido-cur-list)
- (ido-trace "matches" ido-matches)
- (ido-trace "rescan" ido-rescan)
+ (when ido-trace-enable
+ (ido-trace "\nexhibit" this-command)
+ (ido-trace "dir" ido-current-directory)
+ (ido-trace "contents" contents)
+ (ido-trace "list" ido-cur-list)
+ (ido-trace "matches" ido-matches)
+ (ido-trace "rescan" ido-rescan))
(save-excursion
(goto-char (point-max))
(setq refresh t))
((string-equal contents "./")
(setq refresh t))
- ((string-match "\\`~[a-zA-Z0-9]+/\\'" contents)
+ ((string-match "\\`~[-_a-zA-Z0-9]+[$]?/\\'" contents)
(ido-trace "new home" contents)
(ido-set-current-home contents)
(setq refresh t))
((= (length contents) 2)
"/")
(ido-matches
- (concat ido-current-directory (car ido-matches)))
+ (concat ido-current-directory (ido-name (car ido-matches))))
(t
(concat ido-current-directory (substring contents 0 -1)))))
(setq ido-text-init (substring contents -1))
ido-matches
(or (eq ido-enter-matching-directory 'first)
(null (cdr ido-matches)))
- (ido-final-slash (car ido-matches))
+ (ido-final-slash (ido-name (car ido-matches)))
(or try-single-dir-match
(eq ido-enter-matching-directory t)))
(ido-trace "single match" (car ido-matches))
(ido-set-current-directory
- (concat ido-current-directory (car ido-matches)))
+ (concat ido-current-directory (ido-name (car ido-matches))))
(setq ido-exit 'refresh)
(exit-minibuffer))