;;; ido.el --- interactively do things with buffers and files.
-;; Copyright (C) 1996-2004 Free Software Foundation, Inc.
+;; Copyright (C) 1996-2004, 2005 Free Software Foundation, Inc.
;; Author: Kim F. Storm <storm@cua.dk>
;; Based on: iswitchb by Stephen Eglen <stephen@cns.ed.ac.uk>
"Switch between files using substrings."
:group 'extensions
:group 'convenience
+ :version "22.1"
:link '(emacs-commentary-link :tag "Commentary" "ido.el")
:link '(emacs-library-link :tag "Lisp File" "ido.el"))
:require 'ido
:link '(emacs-commentary-link "ido.el")
:set-after '(ido-save-directory-list-file)
- :version "21.4"
:type '(choice (const :tag "Turn on only buffer" buffer)
(const :tag "Turn on only file" file)
(const :tag "Turn on both buffer and file" both)
:type 'boolean
:group 'ido)
+(defcustom ido-file-extensions-order nil
+ "*List of file extensions specifying preferred order of file selections.
+Each element is either a string with `.' as the first char, an empty
+string matching files without extension, or t which is the default order
+of for files with an unlisted file extension."
+ :type '(repeat (choice string
+ (const :tag "Default order" t)))
+ :group 'ido)
+
(defcustom ido-ignore-directories
'("\\`CVS/" "\\`\\.\\./" "\\`\\./")
"*List of regexps or functions matching sub-directory names to ignore."
:type 'integer
:group 'ido)
+(defcustom ido-max-directory-size 30000
+ "*Maximum size (in bytes) for directories to use ido completion.
+If you enter a directory with a size larger than this size, ido will
+not provide the normal completion. To show the completions, use C-a."
+ :type '(choice (const :tag "No limit" nil)
+ (integer :tag "Size in bytes" 30000))
+ :group 'ido)
+
(defcustom ido-rotate-file-list-default nil
"*Non-nil means that `ido' will always rotate file list to get default in front."
:type 'boolean
:type '(choice string (const nil))
:group 'ido)
-(defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]" " [Not readable]")
+(defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]" " [Not readable]" " [Too big]")
"*List of strings used by ido to display the alternatives in the minibuffer.
-There are 9 elements in this list:
+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),
4th element is the string inserted at the end of a truncated list of prospects,
can be completed using TAB,
7th element is the string displayed when there are a no matches, and
8th element is displayed if there is a single match (and faces are not used).
-9th element is displayed when the current directory is non-readable."
+9th element is displayed when the current directory is non-readable.
+10th element is displayed when directory exceeds `ido-max-directory-size'."
:type '(repeat string)
:group 'ido)
"*Font used by ido for highlighting only match."
:group 'ido)
-(defface ido-subdir-face '((((class color))
+(defface ido-subdir-face '((((min-colors 88) (class color))
+ (:foreground "red1"))
+ (((class color))
(:foreground "red"))
(t (:underline t)))
"*Font used by ido for highlighting subdirs in the alternatives."
:group 'ido)
-(defface ido-indicator-face '((((class color))
+(defface ido-indicator-face '((((min-colors 88) (class color))
+ (:foreground "yellow1"
+ :background "red1"
+ :width condensed))
+ (((class color))
(:foreground "yellow"
:background "red"
:width condensed))
;; Remember if current directory is non-readable (so we cannot do completion).
(defvar ido-directory-nonreadable)
+;; Remember if current directory is 'huge' (so we don't want to do completion).
+(defvar ido-directory-too-big)
+
;; Keep current item list if non-nil.
(defvar ido-keep-item-list)
(defun ido-may-cache-directory (&optional dir)
(setq dir (or dir ido-current-directory))
(cond
+ ((ido-directory-too-big-p dir)
+ nil)
((and (ido-is-root-directory dir)
(or ido-enable-tramp-completion
(memq system-type '(windows-nt ms-dos))))
(file-directory-p dir)
(not (file-readable-p dir)))))
+(defun ido-directory-too-big-p (dir)
+ ;; Return t if dir is a directory, but too big to show
+ ;; Do not check for non-readable directories via tramp, as this causes a premature
+ ;; connect on incomplete tramp paths (after entring just method:).
+ (let ((ido-enable-tramp-completion nil))
+ (and (numberp ido-max-directory-size)
+ (ido-final-slash dir)
+ (file-directory-p dir)
+ (> (nth 7 (file-attributes dir)) ido-max-directory-size))))
+
(defun ido-set-current-directory (dir &optional subdir no-merge)
;; Set ido's current directory to DIR or DIR/SUBDIR
(setq dir (ido-final-slash dir t))
(if (get-buffer ido-completion-buffer)
(kill-buffer ido-completion-buffer))
(setq ido-directory-nonreadable (ido-nonreadable-directory-p dir))
+ (setq ido-directory-too-big (and (not ido-directory-nonreadable)
+ (ido-directory-too-big-p dir)))
t))
(defun ido-set-current-home (&optional dir)
ido-rescan nil))
((eq ido-cur-item 'file)
(setq ido-ignored-list nil
- ido-cur-list (ido-make-file-list ido-default-item)))
+ ido-cur-list (and (not ido-directory-nonreadable)
+ (not ido-directory-too-big)
+ (ido-make-file-list ido-default-item))))
((eq ido-cur-item 'dir)
(setq ido-ignored-list nil
- ido-cur-list (ido-make-dir-list ido-default-item)))
+ ido-cur-list (and (not ido-directory-nonreadable)
+ (not ido-directory-too-big)
+ (ido-make-dir-list ido-default-item))))
((eq ido-cur-item 'buffer)
(setq ido-ignored-list nil
ido-cur-list (ido-make-buffer-list ido-default-item)))
(setq ido-set-default-item t))))
;; Handling the require-match must be done in a better way.
- ((and require-match (not (ido-existing-item-p)))
+ ((and require-match
+ (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"))
(t
(ido-name (car ido-matches))))
(cond
- ((eq item 'buffer)
+ ((memq item '(buffer list))
(setq done t))
((string-equal "./" ido-selected)
(if (not ido-mode)
(call-interactively (or fallback 'switch-to-buffer))
(let* ((ido-context-switch-command switch-cmd)
- (buf (ido-read-buffer (or prompt "Buffer: ") default nil initial)))
+ (ido-current-directory nil)
+ (ido-directory-nonreadable nil)
+ (ido-directory-too-big nil)
+ (buf (ido-read-internal 'buffer (or prompt "Buffer: ") 'ido-buffer-history default nil initial)))
;; Choose the buffer name: either the text typed in, or the head
;; of the list of matches
(set-buffer-major-mode buf))
(ido-visit-buffer buf method t))))))
-;;;###autoload
-(defun ido-read-buffer (prompt &optional default require-match initial)
- "Replacement for the built-in `read-buffer'.
-Return the name of a buffer selected.
-PROMPT is the prompt to give to the user. DEFAULT if given is the default
-buffer to be selected, which will go to the front of the list.
-If REQUIRE-MATCH is non-nil, an existing-buffer must be selected.
-If INITIAL is non-nil, it specifies the initial input string."
- (let ((ido-current-directory nil)
- (ido-directory-nonreadable nil)
- (ido-context-switch-command (if (boundp 'ido-context-switch-command) ido-context-switch-command 'ignore)))
- (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match initial)))
-
(defun ido-record-work-directory (&optional dir)
(when (and (numberp ido-max-work-directory-list) (> ido-max-work-directory-list 0))
(if (and (setq dir (or dir ido-current-directory)) (> (length dir) 0))
;; Internal function for ido-find-file and friends
(unless item
(setq item 'file))
- (let* ((ido-current-directory (ido-expand-directory default))
- (ido-directory-nonreadable (ido-nonreadable-directory-p ido-current-directory))
- (ido-context-switch-command switch-cmd)
- filename)
-
- (cond
- ((or (not ido-mode) (ido-is-slow-ftp-host))
- (setq filename t
- ido-exit 'fallback))
-
- ((and (eq item 'file)
+ (let ((ido-current-directory (ido-expand-directory default))
+ (ido-context-switch-command switch-cmd)
+ ido-directory-nonreadable ido-directory-too-big
+ filename)
+
+ (if (or (not ido-mode) (ido-is-slow-ftp-host))
+ (setq filename t
+ ido-exit 'fallback)
+ (setq ido-directory-nonreadable
+ (ido-nonreadable-directory-p ido-current-directory)
+ ido-directory-too-big
+ (and (not ido-directory-nonreadable)
+ (ido-directory-too-big-p ido-current-directory))))
+
+ (when (and (eq item 'file)
(or ido-use-url-at-point ido-use-filename-at-point))
(let (fn d)
(require 'ffap)
(setq d (file-name-directory fn))
(file-directory-p d))
(setq ido-current-directory d)
- (setq initial (file-name-nondirectory fn)))))))
+ (setq initial (file-name-nondirectory fn))))))
(let (ido-saved-vc-hb
(vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
(setq ido-exit 'refresh)
(exit-minibuffer))))
+ (ido-directory-too-big
+ (setq ido-directory-too-big nil)
+ (setq ido-text-init ido-text)
+ (setq ido-exit 'refresh)
+ (exit-minibuffer))
+
((not ido-matches)
(when ido-completion-buffer
(call-interactively (setq this-command ido-cannot-complete-command))))
(defun ido-toggle-ignore ()
"Toggle ignoring files specified with `ido-ignore-files'."
(interactive)
- (setq ido-process-ignore-lists (not ido-process-ignore-lists))
+ (if ido-directory-too-big
+ (setq ido-directory-too-big nil)
+ (setq ido-process-ignore-lists (not ido-process-ignore-lists)))
(setq ido-text-init ido-text)
(setq ido-exit 'refresh)
(exit-minibuffer))
(defun ido-fallback-command ()
"Fallback to non-ido version of current command."
(interactive)
+ (let ((i (length ido-text)))
+ (while (> i 0)
+ (push (aref ido-text (setq i (1- i))) unread-command-events)))
(setq ido-exit 'fallback)
(exit-minibuffer))
(not (equal dir ido-current-directory))
(file-directory-p dir)
(or (not must-match)
+ ;; TODO. check for nonreadable and too-big.
(ido-set-matches1
(if (eq ido-cur-item 'file)
(ido-make-file-list1 dir)
(defun ido-all-completions ()
;; Return unsorted list of all competions.
- (let ((ido-process-ignore-lists nil))
+ (let ((ido-process-ignore-lists nil)
+ (ido-directory-too-big nil))
(cond
((eq ido-cur-item 'file)
(ido-make-file-list1 ido-current-directory))
(t nil))))
-(defun ido-sort-list (items)
- ;; Simple list of file or buffer names
- (sort items (lambda (a b) (string-lessp (ido-no-final-slash a)
- (ido-no-final-slash b)))))
+;; File list sorting
+
+(defun ido-file-lessp (a b)
+ ;; Simple compare two file names.
+ (string-lessp (ido-no-final-slash a) (ido-no-final-slash b)))
+
+
+(defun ido-file-extension-lessp (a b)
+ ;; Compare file names according to ido-file-extensions-order list.
+ (let ((n (compare-strings a 0 nil b 0 nil nil))
+ lessp p)
+ (if (eq n t)
+ nil
+ (if (< n 0)
+ (setq n (1- (- n))
+ p a a b b p
+ lessp t)
+ (setq n (1- n)))
+ (cond
+ ((= n 0)
+ lessp)
+ ((= (aref a n) ?.)
+ (ido-file-extension-aux a b n lessp))
+ (t
+ (while (and (> n 2) (/= (aref a n) ?.))
+ (setq n (1- n)))
+ (if (> n 1)
+ (ido-file-extension-aux a b n lessp)
+ lessp))))))
+
+(defun ido-file-extension-aux (a b n lessp)
+ (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)))
+ (oa
+ (not lessp))
+ (ob
+ lessp)
+ (t
+ lessp))))
+
+(defun ido-file-extension-order (s n)
+ (let ((l ido-file-extensions-order)
+ (i 0) o do)
+ (while l
+ (cond
+ ((eq (car l) t)
+ (setq do i
+ l (cdr l)))
+ ((eq (compare-strings s n nil (car l) 0 nil nil) t)
+ (setq o i
+ l nil))
+ (t
+ (setq l (cdr l))))
+ (setq i (1+ i)))
+ (or o do)))
+
(defun ido-sort-merged-list (items promote)
;; Input is list of ("file" . "dir") cons cells.
(or ido-merge-ftp-work-directories
(not (ido-is-ftp-directory dir)))
(file-directory-p dir)
+ ;; TODO. check for nonreadable and too-big.
(setq fl (if (eq ido-cur-item 'file)
(ido-make-file-list1 dir t)
(ido-make-dir-list1 dir t))))
(defun ido-file-name-all-completions1 (dir)
(cond
((ido-nonreadable-directory-p dir) '())
+ ;; do not check (ido-directory-too-big-p dir) here.
+ ;; Caller must have done that if necessary.
((and ido-enable-tramp-completion
(string-match "\\`/\\([^/:]+:\\([^/:@]+@\\)?\\)\\'" dir))
;; created to allow the user to further modify the order of the file names
;; in this list.
(let ((ido-temp-list (ido-make-file-list1 ido-current-directory)))
- (setq ido-temp-list (ido-sort-list ido-temp-list))
+ (setq ido-temp-list (sort ido-temp-list
+ (if ido-file-extensions-order
+ #'ido-file-extension-lessp
+ #'ido-file-lessp)))
(let ((default-directory ido-current-directory))
(ido-to-end ;; move ftp hosts and visited files to end
(delq nil (mapcar
;; created to allow the user to further modify the order of the
;; directory names in this list.
(let ((ido-temp-list (ido-make-dir-list1 ido-current-directory)))
- (setq ido-temp-list (ido-sort-list ido-temp-list))
+ (setq ido-temp-list (sort ido-temp-list #'ido-file-lessp))
(ido-to-end ;; move . files to end
(delq nil (mapcar
(lambda (x) (if (string-equal (substring x 0 1) ".") x))
(setq display-it t))
(if display-it
(with-output-to-temp-buffer ido-completion-buffer
- (let ((completion-list (ido-sort-list
+ (let ((completion-list (sort
(cond
(ido-use-merged-list
(ido-flatten-merged-list (or ido-matches ido-cur-list)))
((or full-list ido-completion-buffer-all-completions)
(ido-all-completions))
(t
- (copy-sequence (or ido-matches ido-cur-list)))))))
+ (copy-sequence (or ido-matches ido-cur-list))))
+ #'ido-file-lessp)))
(if (featurep 'xemacs)
;; XEmacs extents are put on by default, doesn't seem to be
;; any way of switching them off.
(expand-file-name "/" ido-current-directory)
"/"))
(setq refresh t))
- ((and ido-directory-nonreadable
+ ((and (or ido-directory-nonreadable ido-directory-too-big)
(file-directory-p (concat ido-current-directory (file-name-directory contents))))
(ido-set-current-directory
(concat ido-current-directory (file-name-directory contents)))
(when (and (not ido-matches)
(not ido-directory-nonreadable)
+ (not ido-directory-too-big)
;; ido-rescan ?
ido-process-ignore-lists
ido-ignored-list)
(not (ido-is-root-directory))
(> (length contents) 1)
(not (string-match "[$]" contents))
- (not ido-directory-nonreadable))
+ (not ido-directory-nonreadable)
+ (not ido-directory-too-big))
(ido-trace "merge?")
(if ido-use-merged-list
(ido-undo-merge-work-directory contents nil)
(cond
(ido-directory-nonreadable
(or (nth 8 ido-decorations) " [Not readable]"))
+ (ido-directory-too-big
+ (or (nth 9 ido-decorations) " [Too big]"))
(ido-report-no-match
(nth 6 ido-decorations)) ;; [No match]
(t "")))
(put 'dired-do-rename 'ido 'ignore)
+;;;###autoload
+(defun ido-read-buffer (prompt &optional default require-match)
+ "Ido replacement for the built-in `read-buffer'.
+Return the name of a buffer selected.
+PROMPT is the prompt to give to the user. DEFAULT if given is the default
+buffer to be selected, which will go to the front of the list.
+If REQUIRE-MATCH is non-nil, an existing-buffer must be selected."
+ (let* ((ido-current-directory nil)
+ (ido-directory-nonreadable nil)
+ (ido-directory-too-big nil)
+ (ido-context-switch-command 'ignore)
+ (buf (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match)))
+ (if (eq ido-exit 'fallback)
+ (let ((read-buffer-function nil))
+ (read-buffer prompt default require-match))
+ buf)))
+
;;;###autoload
(defun ido-read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
- "Read file name, prompting with PROMPT and completing in directory DIR.
+ "Ido replacement for the built-in `read-file-name'.
+Read file name, prompting with PROMPT and completing in directory DIR.
See `read-file-name' for additional parameters."
(let (filename)
(cond
(vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
(ido-current-directory (ido-expand-directory dir))
(ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
+ (ido-directory-too-big (and (not ido-directory-nonreadable)
+ (ido-directory-too-big-p ido-current-directory)))
(ido-work-directory-index -1)
(ido-work-file-index -1)
(ido-find-literal nil))
;;;###autoload
(defun ido-read-directory-name (prompt &optional dir default-dirname mustmatch initial)
- "Read directory name, prompting with PROMPT and completing in directory DIR.
-See `read-file-name' for additional parameters."
+ "Ido replacement for the built-in `read-directory-name'.
+Read directory name, prompting with PROMPT and completing in directory DIR.
+See `read-directory-name' for additional parameters."
(let* (filename
(ido-context-switch-command 'ignore)
ido-saved-vc-hb
(ido-current-directory (ido-expand-directory dir))
(ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
+ (ido-directory-too-big (and (not ido-directory-nonreadable)
+ (ido-directory-too-big-p ido-current-directory)))
(ido-work-directory-index -1)
(ido-work-file-index -1))
(setq filename
;;;###autoload
(defun ido-completing-read (prompt choices &optional predicate require-match initial-input hist def)
- "Read a string in the minibuffer with ido-style completion.
+ "Ido replacement for the built-in `completing-read'.
+Read a string in the minibuffer with ido-style completion.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
CHOICES is a list of strings which are the possible completions.
PREDICATE is currently ignored; it is included to be compatible
DEF, if non-nil, is the default value."
(let ((ido-current-directory nil)
(ido-directory-nonreadable nil)
+ (ido-directory-too-big nil)
(ido-context-switch-command 'ignore)
(ido-choice-list choices))
(ido-read-internal 'list prompt hist def require-match initial-input)))