;;; ido.el --- interactively do things with buffers and files.
-;; Copyright (C) 1996-2003 Free Software Foundation, Inc.
+;; Copyright (C) 1996-2004 Free Software Foundation, Inc.
;; Author: Kim F. Storm <storm@cua.dk>
;; Based on: iswitchb by Stephen Eglen <stephen@cns.ed.ac.uk>
;;; Acknowledgements
;; Infinite amounts of gratitude goes to Stephen Eglen <stephen@cns.ed.ac.uk>
-;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
+;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
;; for ido-switch-buffer and found the inspiration for ido-find-file.
;; The ido package would never have existed without his work.
-;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex Schroeder,
-;; Bill Benedetto, and Stephen Eglen for bug fixes and improvements.
+;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex
+;; Schroeder, Bill Benedetto, Stephen Eglen, and many others for bug
+;; fixes and improvements.
;;; History
;; so I invented a common "ido-" namespace for the merged packages.
;;
;; This version is based on ido.el version 1.57 released on
-;; gnu.emacs.sources adapted for emacs 21.4 to use command remapping
+;; gnu.emacs.sources adapted for emacs 21.5 to use command remapping
;; and optionally hooking the read-buffer and read-file-name functions.
;;
;; Prefix matching was added by Klaus Berndl <klaus.berndl@sdm.de> based on
;; most recent, when I use ido-switch-buffer, I first of all get
;; presented with the list of all the buffers
;;
-;; Buffer: {123456,123}
+;; Buffer: {123456,123}
;;
;; If I then press 2:
;; Buffer: 2[3]{123456,123}
;; drive, enter X:/ where X is the drive letter. You can also visit
;; files on other hosts using the ange-ftp notations `/host:' and
;; `/user@host:'. See the variable `ido-slow-ftp-hosts' if you want
-;; to inhibit the ido substring matching for ftp access.
+;; to inhibit the ido substring matching for ftp access.
;;
;; If for some reason you cannot specify the proper file using
;; ido-find-file, you can press C-f to enter the normal find-file.
(defcustom ido-mode nil
"Determines for which functional group \(buffer and files) ido behavior
should be enabled. The following values are possible:
-- 'buffer: Turn only on ido buffer behavior \(switching, killing,
- displaying...)
-- 'file: Turn only on ido file behavior \(finding, writing, inserting...)
-- 'both: Turn on ido buffer and file behavior.
-- nil: Turn off any ido switching.
+- `buffer': Turn only on ido buffer behavior \(switching, killing,
+ displaying...)
+- `file': Turn only on ido file behavior \(finding, writing, inserting...)
+- `both': Turn on ido buffer and file behavior.
+- `nil': Turn off any ido switching.
Setting this variable directly does not take effect;
use either \\[customize] or the function `ido-mode'."
: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)
+ :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)
(const :tag "Switch off all" nil))
frame or in the other frame.
`always-frame' If a file is visible in another frame, raise that
frame. Otherwise, visit the file in the same window."
- :type '(choice (const samewindow)
+ :type '(choice (const samewindow)
(const otherwindow)
(const display)
- (const otherframe)
+ (const otherframe)
(const maybe-frame)
(const always-frame))
:group 'ido)
(defcustom ido-default-buffer-method 'always-frame
"*How to switch to new buffer when using `ido-switch-buffer'.
See ido-default-file-method for details."
- :type '(choice (const samewindow)
+ :type '(choice (const samewindow)
(const otherwindow)
(const display)
- (const otherframe)
+ (const otherframe)
(const maybe-frame)
(const always-frame))
:group 'ido)
:type 'boolean
:group 'ido)
+(defcustom ido-confirm-unique-completion nil
+ "*Non-nil means that even a unique completion must be confirmed.
+This means that \\[ido-complete] must always be followed by \\[ido-exit-minibuffer]
+even when there is only one unique completion."
+ :type 'boolean
+ :group 'ido)
+
(defcustom ido-cannot-complete-command 'ido-completion-help
"*Command run when `ido-complete' can't complete any more.
The most useful values are `ido-completion-help', which pops up a
:group 'ido)
+(defcustom ido-use-filename-at-point nil
+ "*Non-nil means that ido shall look for a filename at point.
+If found, use that as the starting point for filename selection."
+ :type 'boolean
+ :group 'ido)
+
+
+(defcustom ido-use-url-at-point nil
+ "*Non-nil means that ido shall look for a URL at point.
+If found, call `find-file-at-point' to visit it."
+ :type 'boolean
+ :group 'ido)
+
+
(defcustom ido-enable-tramp-completion t
"*Non-nil means that ido shall perform tramp method and server name completion.
A tramp file name uses the following syntax: /method:user@host:filename."
:group 'ido)
(defcustom ido-record-ftp-work-directories t
- "*Non-nil means that remote directories are recorded in work directory list."
+ "*Non-nil means record ftp file names in the work directory list."
:type 'boolean
:group 'ido)
(defcustom ido-merge-ftp-work-directories nil
- "*Nil means that remote directories in work directory list are ignored during merge."
+ "*If nil means merging ignores ftp file names in the work directory list."
:type 'boolean
:group 'ido)
(defcustom ido-enter-single-matching-directory 'slash
"*Automatically enter sub-directory if it is the only matching item, if non-nil.
If value is 'slash, only enter if typing final slash, else do it always."
- :type '(choice (const :tag "Never" nil)
+ :type '(choice (const :tag "Never" nil)
(const :tag "When typing /" slash)
(other :tag "Always" t))
:group 'ido)
"*Specify whether a new buffer is created if no buffer matches substring.
Choices are 'always to create new buffers unconditionally, 'prompt to
ask user whether to create buffer, or 'never to never create new buffer."
- :type '(choice (const always)
+ :type '(choice (const always)
(const prompt)
(const never))
:group 'ido)
:type '(choice string (const nil))
:group 'ido)
-(defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]")
+(defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]" " [Not readable]")
"*List of strings used by ido to display the alternatives in the minibuffer.
-There are 8 elements in this list, each is a pair of strings:
+There are 9 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,
5th and 6th elements are used as brackets around the common match string which
can be completed using TAB,
-7th element is the string displayed when there are a no matches, and
-8th element displayed if there is a single match (and faces are not used)."
+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."
:type '(repeat string)
:group 'ido)
"*Font used by ido for highlighting first match."
:group 'ido)
-(defface ido-only-match-face '((((class color))
+(defface ido-only-match-face '((((class color))
(:foreground "ForestGreen"))
(t (:italic t)))
"*Font used by ido for highlighting only match."
:group 'ido)
-(defface ido-subdir-face '((((class color))
+(defface ido-subdir-face '((((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 '((((class color))
(:foreground "yellow"
:background "red"
:width condensed))
"*List of functions to run when the find-file prompt is created.
Each function on the list may modify the following dynamically bound
variables:
- dirname - the (abbreviated) directory name to be modified by the hook functions
- max-width - the max width of the resulting dirname; set to nil to inhibit truncation
- prompt - the basic prompt (e.g. \"Find File: \")
- literal - the string shown if doing `literal' find; set to nil to omit
- vc-off - the string shown if version control is inhibited; set to nit to omit
- prefix - normally nil, but may be set to a fixed prefix for the dirname
+ dirname - the (abbreviated) directory name
+ to be modified by the hook functions
+ max-width - the max width of the resulting dirname; nil means no limit
+ prompt - the basic prompt (e.g. \"Find File: \")
+ literal - the string shown if doing \"literal\" find; set to nil to omit
+ vc-off - the string shown if version control is inhibited; set to nit to omit
+ 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
- item - equals 'file or 'dir depending on the current mode."
+ item - equals `file' or `dir' depending on the current mode."
:type 'hook
:group 'ido)
It is intended for use in customizing ido for interoperation
with other packages. For instance:
- \(add-hook 'ido-minibuffer-setup-hook
+ \(add-hook 'ido-minibuffer-setup-hook
\(function
\(lambda ()
\(make-local-variable 'max-mini-window-height)
(defvar ido-work-file-list nil
"List of actual work file names.
-The current file name (sans directory) is inserted at the front of this list
-whenever a file is opened with ido-find-file and family.")
+Opening a file with `ido-find-file' and similar functions
+inserts the current file name (relative to its containing directory)
+at the front of this list.")
(defvar ido-dir-file-cache nil
- "List of file-name-all-completions results.
-Each element in the list is of the form (dir (mtime) file...).")
+ "List of `file-name-all-completions' results.
+Each element in the list is of the form (DIR (MTIME) FILE...).")
(defvar ido-ignore-item-temp-list nil
"List of items to ignore in current ido invocation.
(defvar ido-report-no-match t
"Report [No Match] when no completions matches ido-text.")
-(defvar ido-exit nil
- "Flag to monitor how `ido-find-file' exits.
+(defvar ido-exit nil
+ "Flag to monitor how `ido-find-file' exits.
If equal to `takeprompt', we use the prompt as the file name to be
selected.")
"Delay timer for auto merge.")
(defvar ido-use-mycompletion-depth 0
- "Non-nil means use `ido' completion feedback.
+ "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.")
;; `ido-cur-list'. It is in no specific order.
(defvar ido-ignored-list)
+;; Remember if current directory is non-readable (so we cannot do completion).
+(defvar ido-directory-nonreadable)
+
;; Keep current item list if non-nil.
(defvar ido-keep-item-list)
;; Value is a list (ido-text dir cur-list ignored-list matches).
(defvar ido-pre-merge-state)
-;; Original value of vc-master-templates for use in ido-toggle-vc.
-(defvar ido-saved-vc-mt)
+;; Original value of vc-handled-backends for use in ido-toggle-vc.
+(defvar ido-saved-vc-hb)
;; Stores temporary state of literal find file.
(defvar ido-find-literal)
(string-match "\\`/[^:/][^:/]+:\\'" dir))))
(defun ido-is-ftp-directory (&optional dir)
- (string-match
+ (string-match
(if ido-enable-tramp-completion
"\\`/[^/:][^/:]+:" ;; like tramp-file-name-regexp-unified, but doesn't match single drive letters
"\\`/[^/:][^/:]+:/")
(setq dir (or dir ido-current-directory))
;; (featurep 'ange-ftp)
;; (ange-ftp-ftp-name dir)
- (string-match
+ (string-match
(if ido-enable-tramp-completion
"\\`/\\([^/]+[@:]\\)*\\([^@/:][^@/:]+\\):"
"\\`/\\([^/:]*@\\)?\\([^@/:][^@/:]+\\):/")
(setq r (cons (car l) r)))
(setq l (cdr l)))
(nreverse r))))
- (setq ido-work-directory-list
+ (setq ido-work-directory-list
(and (listp ido-work-directory-list)
(let ((l ido-work-directory-list) r)
(while l
(setq r (cons (car l) r)))
(setq l (cdr l)))
(nreverse r))))
- (setq ido-work-file-list
+ (setq ido-work-file-list
(and (listp ido-work-file-list)
(let ((l ido-work-file-list) r)
(while l
(setq r (cons (car l) r)))
(setq l (cdr l)))
(nreverse r))))
- (setq ido-dir-file-cache
+ (setq ido-dir-file-cache
(and (listp ido-dir-file-cache)
(let ((l ido-dir-file-cache) r)
(while l
(defvar ido-minor-mode-map-entry nil)
;;;###autoload
-(defun ido-mode (&optional arg nobind)
+(defun ido-mode (&optional arg)
"Toggle ido speed-ups on or off.
With ARG, turn ido speed-up on if arg is positive, off otherwise.
-If second argument NOBIND is non-nil, no keys are rebound; otherwise,
-turning on ido-mode will modify the default keybindings for the
-find-file and switch-to-buffer families of commands to the ido
-versions of these functions.
-However, if second arg equals 'files, bind only for files, or if it
-equals 'buffers, bind only for buffers.
+Turning on ido-mode will remap (via a minor-mode keymap) the default
+keybindings for the `find-file' and `switch-to-buffer' families of
+commands to the ido versions of these functions.
+However, if ARG arg equals 'files, remap only commands for files, or
+if it equals 'buffers, remap only commands for buffer switching.
This function also adds a hook to the minibuffer."
(interactive "P")
(setq ido-mode
- (cond
+ (cond
((null arg) (if ido-mode nil 'both))
((eq arg t) 'both)
((eq arg 'files) 'file)
"Enable ido everywhere file and directory names are read."
(interactive "P")
(setq ido-everywhere (if arg
- (> (prefix-numeric-value arg) 0)
+ (> (prefix-numeric-value arg) 0)
(not ido-everywhere)))
- (setq read-file-name-function
+ (setq read-file-name-function
(and ido-everywhere (memq ido-mode '(both file))
'ido-read-file-name))
(setq read-buffer-function
'ido-read-buffer)))
-;;; IDO KEYMAP
+;;; IDO KEYMAP
(defun ido-define-mode-map ()
"Set up the keymap for `ido'."
(let (map)
(define-key map "\d" 'ido-delete-backward-updir)
(define-key map [(meta backspace)] 'ido-delete-backward-word-updir)
(define-key map [(control backspace)] 'ido-up-directory)
+ (define-key map "\C-l" 'ido-reread-directory)
(define-key map [(meta ?b)] 'ido-next-work-file)
(define-key map [(meta ?d)] 'ido-wide-find-dir)
(define-key map [(meta ?f)] 'ido-wide-find-file)
(when (eq ido-cur-item 'file)
(define-key map "\C-k" 'ido-delete-file-at-head)
(define-key map "\C-o" 'ido-copy-current-word)
- (define-key map "\C-l" 'ido-reread-directory)
(define-key map "\C-w" 'ido-copy-current-file-name)
(define-key map [(meta ?l)] 'ido-toggle-literal)
(define-key map "\C-v" 'ido-toggle-vc)
(define-key map "\C-k" 'ido-kill-buffer-at-head)
)
+ (when (if (boundp 'viper-mode) viper-mode)
+ (define-key map [remap viper-intercept-ESC-key] 'ignore)
+ (when (memq ido-cur-item '(file dir))
+ (define-key map [remap viper-backward-char] 'ido-delete-backward-updir)
+ (define-key map [remap viper-del-backward-char-in-insert] 'ido-delete-backward-updir)
+ (define-key map [remap viper-delete-backward-word] 'ido-delete-backward-word-updir)))
+
(setq ido-mode-map map)
(run-hooks 'ido-define-mode-map-hook)))
(fix-it (concat dir "/"))
(t nil)))
+(defun ido-no-final-slash (s)
+ ;; Remove optional final slash from string S
+ (let ((l (1- (length s))))
+ (if (and (> l 0) (eq (aref s l) ?/))
+ (substring s 0 l)
+ s)))
+
+(defun ido-nonreadable-directory-p (dir)
+ ;; Return t if dir is a directory, but not readable
+ ;; 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 (ido-final-slash dir)
+ (file-directory-p dir)
+ (not (file-readable-p dir)))))
+
(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))
(setq ido-current-directory dir)
(if (get-buffer ido-completion-buffer)
(kill-buffer ido-completion-buffer))
+ (setq ido-directory-nonreadable (ido-nonreadable-directory-p dir))
t))
(defun ido-set-current-home (&optional dir)
(floor (* (frame-width) ido-max-file-prompt-width))
ido-max-file-prompt-width))
(literal (and (boundp 'ido-find-literal) ido-find-literal "(literal) "))
- (vc-off (and ido-saved-vc-mt (not vc-master-templates) "[-VC] "))
+ (vc-off (and ido-saved-vc-hb (not vc-handled-backends) "[-VC] "))
(prefix nil)
(rule ido-rewrite-file-prompt-rules))
(let ((case-fold-search nil))
(funcall (cdr (car rule)) dirname))))
(setq rule (cdr rule))))
(run-hooks 'ido-rewrite-file-prompt-functions)
- (concat prompt
+ (concat prompt
; (if ido-process-ignore-lists "" "&")
(or literal "")
(or vc-off "")
(or prefix "")
(let ((l (length dirname)))
(if (and max-width (> max-width 0) (> l max-width))
- (let* ((s (substring dirname (- max-width)))
+ (let* ((s (substring dirname (- max-width)))
(i (string-match "/" s)))
(concat "..." (if i (substring s i) s)))
dirname)))))
(defun ido-read-internal (item prompt history &optional default require-match initial)
"Perform the ido-read-buffer and ido-read-file-name functions.
-Return the name of a buffer or file selected.
+Return the name of a buffer or file selected.
PROMPT is the prompt to give to the user.
DEFAULT if given is the default directory to start with.
If REQUIRE-MATCH is non-nil, an existing file must be selected.
(if (bufferp default) (buffer-name default) default))
((stringp default) default)
((eq item 'file)
- (and ido-enable-last-directory-history
+ (and ido-enable-last-directory-history
(let ((d (assoc ido-current-directory ido-last-directory-list)))
(and d (cdr d)))))))
(if (member ido-default-item ido-ignore-item-temp-list)
ido-use-merged-list t)
(ido-trace "Merged" t)
))))
-
+
(cond
(ido-keep-item-list
(setq ido-keep-item-list nil
(ido-set-matches)
(if (and ido-matches (eq ido-try-merged-list 'auto))
(setq ido-try-merged-list t))
- (let
+ (let
((minibuffer-local-completion-map ido-mode-map)
(max-mini-window-height (or ido-max-window-height
(and (boundp 'max-mini-window-height) max-mini-window-height)))
(setq ido-exit nil)
(setq ido-final-text
(catch 'ido
- (completing-read
+ (completing-read
(ido-make-prompt item prompt)
'(("dummy" . 1)) nil nil ; table predicate require-match
(prog1 ido-text-init (setq ido-text-init nil)) ;initial-contents
(cond
((eq ido-exit 'refresh)
- (if (and (eq ido-use-merged-list 'auto)
+ (if (and (eq ido-use-merged-list 'auto)
(or (input-pending-p)))
(setq ido-use-merged-list nil
ido-keep-item-list t))
ido-exit nil))
((memq ido-exit '(edit chdir))
- (cond
+ (cond
((memq ido-cur-item '(file dir))
- (let* ((process-environment (cons "HOME=/" process-environment)) ;; cheat read-file-name
- (read-file-name-function nil)
+ (let* ((read-file-name-function nil)
(edit (eq ido-exit 'edit))
(d ido-current-directory)
(f ido-text-init)
(setq ido-text-init "")
(while new
(setq new (if edit
- (read-file-name (concat prompt "[EDIT] ") d (concat d f) nil f)
+ (read-file-name (concat prompt "[EDIT] ")
+ (expand-file-name d)
+ (concat d f) nil f)
f)
d (or (file-name-directory new) "/")
f (file-name-nondirectory new)
edit t)
- (if (or
+ (if (or
(file-directory-p d)
(and (yes-or-no-p (format "Create directory %s? " d))
- (condition-case nil
+ (condition-case nil
(progn (make-directory d t) t)
(error
(message "Could not create directory")
;; Choose the buffer name: either the text typed in, or the head
;; of the list of matches
- (cond
+ (cond
((eq ido-exit 'findfile)
(ido-file-internal ido-default-file-method nil nil nil nil ido-text))
;;;###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.
+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))
+ (let ((ido-current-directory nil)
+ (ido-directory-nonreadable nil))
(ido-read-internal 'buffer prompt 'ido-buffer-history default require-match initial)))
(defun ido-record-work-directory (&optional dir)
ido-text-init ido-text
ido-rotate-temp t)
(exit-minibuffer))))
-
+
(defun ido-record-work-file (name)
;; Save NAME in ido-work-file-list
(when (and (numberp ido-max-work-file-list) (> ido-max-work-file-list 0))
(if (> (length ido-work-file-list) ido-max-work-file-list)
(setcdr (nthcdr (1- ido-max-work-file-list) ido-work-file-list) nil))))
+(defun ido-expand-directory (dir)
+ ;; Expand DIR or use DEFAULT-DIRECTORY if nil.
+ ;; Add final slash to result in case it was missing from DEFAULT-DIRECTORY.
+ (ido-final-slash (expand-file-name (or dir default-directory)) t))
+
(defun ido-file-internal (method &optional fallback default prompt item initial)
;; Internal function for ido-find-file and friends
- (let ((ido-current-directory (expand-file-name (or default default-directory)))
- filename)
-
- (if (or (not ido-mode) (ido-is-slow-ftp-host))
- (setq filename t
- ido-exit 'fallback))
+ (unless item
+ (setq item 'file))
+ (let* ((ido-current-directory (ido-expand-directory default))
+ (ido-directory-nonreadable (ido-nonreadable-directory-p ido-current-directory))
+ filename)
- (let (ido-saved-vc-mt
- (vc-master-templates (and (boundp 'vc-master-templates) vc-master-templates))
+ (cond
+ ((or (not ido-mode) (ido-is-slow-ftp-host))
+ (setq filename t
+ ido-exit 'fallback))
+
+ ((and (eq item 'file)
+ (or ido-use-url-at-point ido-use-filename-at-point))
+ (let (fn d)
+ (require 'ffap)
+ ;; Duplicate code from ffap-guesser as we want different behaviour for files and URLs.
+ (cond
+ ((and ido-use-url-at-point
+ ffap-url-regexp
+ (ffap-fixup-url (or (ffap-url-at-point)
+ (ffap-gopher-at-point))))
+ (setq ido-exit 'ffap
+ filename t))
+
+ ((and ido-use-filename-at-point
+ (setq fn (ffap-string-at-point))
+ (not (string-match "^http:/" fn))
+ (setq d (file-name-directory fn))
+ (file-directory-p d))
+ (setq ido-current-directory d)
+ (setq initial (file-name-nondirectory fn)))))))
+
+ (let (ido-saved-vc-hb
+ (vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
(ido-work-directory-index -1)
(ido-work-file-index -1)
(ido-find-literal nil))
(unless filename
- (setq ido-saved-vc-mt vc-master-templates)
- (setq filename (ido-read-internal (or item 'file)
+ (setq ido-saved-vc-hb vc-handled-backends)
+ (setq filename (ido-read-internal item
(or prompt "Find file: ")
'ido-file-history nil nil initial)))
((eq ido-exit 'dired)
(dired (concat ido-current-directory (or ido-text ""))))
+ ((eq ido-exit 'ffap)
+ (find-file-at-point))
+
((eq method 'alt-file)
(ido-record-work-file filename)
(setq default-directory ido-current-directory)
((eq method 'insert)
(ido-record-work-file filename)
(setq filename (concat ido-current-directory filename))
- (ido-record-command
+ (ido-record-command
(if ido-find-literal 'insert-file-literally 'insert-file)
filename)
(ido-record-work-directory)
"Try and complete the current pattern amongst the file names."
(interactive)
(let (res)
- (cond
+ (cond
((and (memq ido-cur-item '(file dir))
(string-match "[$]" ido-text))
(let ((evar (substitute-in-file-name (concat ido-current-directory ido-text))))
(if (not (file-exists-p (file-name-directory evar)))
- (message "Expansion generates non-existing directory")
+ (message "Expansion generates non-existing directory name")
(if (file-directory-p evar)
(ido-set-current-directory evar)
(let ((d (or (file-name-directory evar) "/"))
((not ido-matches)
(when ido-completion-buffer
(call-interactively (setq this-command ido-cannot-complete-command))))
-
+
((and (= 1 (length ido-matches))
(not (and ido-enable-tramp-completion
(string-equal ido-current-directory "/")
(string-match "..[@:]\\'" (car ido-matches)))))
;; only one choice, so select it.
- (exit-minibuffer))
-
+ (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))))
+
(t ;; else there could be some completions
(setq res ido-common-match-string)
(if (and (not (memq res '(t nil)))
(setq ido-try-merged-list t))
((not ido-use-merged-list)
(ido-merge-work-directories))))
-
+
;;; TOGGLE FUNCTIONS
(defun ido-toggle-case ()
(interactive)
(if (and ido-mode (eq ido-cur-item 'file))
(progn
- (setq vc-master-templates
- (if vc-master-templates nil ido-saved-vc-mt))
+ (setq vc-handled-backends
+ (if vc-handled-backends nil ido-saved-vc-hb))
(setq ido-text-init ido-text)
(setq ido-exit 'keep)
(exit-minibuffer))))
(ido-up-directory t)))
((and ido-pre-merge-state (string-equal (car ido-pre-merge-state) ido-text))
(ido-undo-merge-work-directory (substring ido-text 0 -1) t t))
+ ((eq this-original-command 'viper-backward-char)
+ (funcall this-original-command (prefix-numeric-value count)))
+ ((eq this-original-command 'viper-del-backward-char-in-insert)
+ (funcall this-original-command))
(t
(delete-backward-char (prefix-numeric-value count)))))
(if (= (minibuffer-prompt-end) (point))
(if (not count)
(ido-up-directory t))
- (backward-kill-word (prefix-numeric-value count))))
+ (if (eq this-original-command 'viper-delete-backward-word)
+ (funcall this-original-command (prefix-numeric-value count))
+ (backward-kill-word (prefix-numeric-value count)))))
(defun ido-get-work-directory (&optional incr must-match)
(let ((n (length ido-work-directory-list))
"Prompt for FILE to search for using find, starting from current directory."
(interactive)
(unless file
- (setq file (read-string (concat "Wide find file: " ido-current-directory) ido-text)))
+ (let ((enable-recursive-minibuffers t))
+ (setq file
+ (read-string (concat "Wide find file: " ido-current-directory) ido-text))))
(when (> (length file) 0)
(setq ido-use-merged-list t ido-try-merged-list 'wide)
(setq ido-exit 'refresh)
"Prompt for DIR to search for using find, starting from current directory."
(interactive)
(unless dir
- (setq dir (read-string (concat "Wide find directory: " ido-current-directory) ido-text)))
+ (let ((enable-recursive-minibuffers t))
+ (setq dir
+ (read-string (concat "Wide find directory: " ido-current-directory) ido-text))))
(when (> (length dir) 0)
(setq ido-use-merged-list t ido-try-merged-list 'wide)
(setq ido-exit 'refresh)
"Prompt for DIR to create in current directory."
(interactive)
(unless dir
- (setq dir (read-string (concat "Make directory: " ido-current-directory) ido-text)))
+ (let ((enable-recursive-minibuffers t))
+ (setq dir
+ (read-string (concat "Make directory: " ido-current-directory) ido-text))))
(when (> (length dir) 0)
(setq dir (concat ido-current-directory dir))
(unless (file-exists-p dir)
(let* ((bfname (buffer-file-name ido-entry-buffer))
(name (and bfname (file-name-nondirectory bfname))))
(when name
- (setq ido-text-init
- (if (or all
+ (setq ido-text-init
+ (if (or all
(not (equal (file-name-directory bfname) ido-current-directory))
(not (string-match "\\.[^.]*\\'" name)))
name
(setq ido-exit 'refresh
ido-try-merged-list nil)
(exit-minibuffer))))
-
+
(defun ido-copy-current-word (all)
"Insert current word (file or directory name) from current buffer."
(interactive "P")
ido-exit 'refresh)))
(exit-minibuffer))))
-(defun ido-next-match ()
+(defun ido-next-match ()
"Put first element of `ido-matches' at the end of the list."
(interactive)
(if ido-matches
(setq ido-rescan t)
(setq ido-rotate t))))
-(defun ido-prev-match ()
+(defun ido-prev-match ()
"Put last element of `ido-matches' at the front of the list."
(interactive)
(if ido-matches
(setq ido-rescan t)
(setq ido-rotate t))))
-(defun ido-next-match-dir ()
+(defun ido-next-match-dir ()
"Find next directory in match list.
If work directories have been merged, cycle through directories for
first matching file."
(if (< i cnt)
(setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
-(defun ido-prev-match-dir ()
+(defun ido-prev-match-dir ()
"Find previous directory in match list.
If work directories have been merged, cycle through directories
for first matching file."
(if (> i 0)
(setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
-(defun ido-restrict-to-matches ()
+(defun ido-restrict-to-matches ()
"Set current item list to the currently matched items."
(interactive)
(when ido-matches
(defun ido-sort-list (items)
;; Simple list of file or buffer names
- (sort items (lambda (a b) (string-lessp a b))))
+ (sort items (lambda (a b) (string-lessp (ido-no-final-slash a)
+ (ido-no-final-slash b)))))
(defun ido-sort-merged-list (items promote)
;; Input is list of ("file" . "dir") cons cells.
(defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
;; As ido-run-find-command, but returns a list of cons pairs ("file" . "dir")
- (let ((filenames
- (split-string
+ (let ((filenames
+ (split-string
(shell-command-to-string
(concat "find " dir " -name \"" (if prefix "" "*") file "*\" -type " (if finddir "d" "f") " -print"))))
filename d f
(defun ido-make-buffer-list1 (&optional frame visible)
;; Return list of non-ignored buffer names
- (delq nil
+ (delq nil
(mapcar
(lambda (x)
(let ((name (buffer-name x)))
(defun ido-make-buffer-list (default)
;; Return the current list of buffers.
;; Currently visible buffers are put at the end of the list.
- ;; The hook `ido-make-buflist-hook' is run after the list has been
+ ;; The hook `ido-make-buflist-hook' is run after the list has been
;; created to allow the user to further modify the order of the buffer names
;; in this list. If DEFAULT is non-nil, and corresponds to an existing buffer,
;; it is put to the start of the list.
(setq ido-temp-list ido-current-buffers))
(if default
(progn
- (setq ido-temp-list
+ (setq ido-temp-list
(delete default ido-temp-list))
- (setq ido-temp-list
+ (setq ido-temp-list
(cons default ido-temp-list))))
(run-hooks 'ido-make-buffer-list-hook)
ido-temp-list))
(defun ido-to-end (items)
;; Move the elements from ITEMS to the end of `ido-temp-list'
- (mapcar
- (lambda (elem)
+ (mapcar
+ (lambda (elem)
(setq ido-temp-list (delq elem ido-temp-list)))
items)
(if ido-temp-list
(setq ido-temp-list items)))
(defun ido-file-name-all-completions1 (dir)
- (if (and ido-enable-tramp-completion
- (string-match "\\`/\\([^/:]+:\\([^/:@]+@\\)?\\)\\'" dir))
-
- ;; Trick tramp's file-name-all-completions handler to DTRT, as it
- ;; has some pretty obscure requirements. This seems to work...
- ;; /ftp: => (f-n-a-c "/ftp:" "")
- ;; /ftp:kfs: => (f-n-a-c "" "/ftp:kfs:")
- ;; /ftp:kfs@ => (f-n-a-c "ftp:kfs@" "/")
- ;; /ftp:kfs@kfs: => (f-n-a-c "" "/ftp:kfs@kfs:")
- ;; Currently no attempt is made to handle multi: stuff.
-
- (let* ((prefix (match-string 1 dir))
- (user-flag (match-beginning 2))
- (len (and prefix (length prefix)))
- compl)
- (if user-flag
- (setq dir (substring dir 1)))
- (require 'tramp nil t)
- (ido-trace "tramp complete" dir)
- (setq compl (file-name-all-completions dir (if user-flag "/" "")))
- (if (> len 0)
- (mapcar (lambda (c) (substring c len)) compl)
- compl))
- (file-name-all-completions "" dir)))
+ (cond
+ ((ido-nonreadable-directory-p dir) '())
+ ((and ido-enable-tramp-completion
+ (string-match "\\`/\\([^/:]+:\\([^/:@]+@\\)?\\)\\'" dir))
+
+ ;; Trick tramp's file-name-all-completions handler to DTRT, as it
+ ;; has some pretty obscure requirements. This seems to work...
+ ;; /ftp: => (f-n-a-c "/ftp:" "")
+ ;; /ftp:kfs: => (f-n-a-c "" "/ftp:kfs:")
+ ;; /ftp:kfs@ => (f-n-a-c "ftp:kfs@" "/")
+ ;; /ftp:kfs@kfs: => (f-n-a-c "" "/ftp:kfs@kfs:")
+ ;; Currently no attempt is made to handle multi: stuff.
+
+ (let* ((prefix (match-string 1 dir))
+ (user-flag (match-beginning 2))
+ (len (and prefix (length prefix)))
+ compl)
+ (if user-flag
+ (setq dir (substring dir 1)))
+ (require 'tramp nil t)
+ (ido-trace "tramp complete" dir)
+ (setq compl (file-name-all-completions dir (if user-flag "/" "")))
+ (if (> len 0)
+ (mapcar (lambda (c) (substring c len)) compl)
+ compl)))
+ (t
+ (file-name-all-completions "" dir))))
(defun ido-file-name-all-completions (dir)
;; Return name of all files in DIR
(stringp dir) (> (length dir) 0)
(ido-may-cache-directory dir))
(let* ((cached (assoc dir ido-dir-file-cache))
- (ctime (nth 1 cached))
+ (ctime (nth 1 cached))
(ftp (ido-is-ftp-directory dir))
(attr (if ftp nil (file-attributes dir)))
(mtime (nth 5 attr))
;; Return list of non-ignored files in DIR
;; If MERGED is non-nil, each file is cons'ed with DIR
(and (or (ido-is-tramp-root dir) (file-directory-p dir))
- (delq nil
+ (delq nil
(mapcar
(lambda (name)
(if (not (ido-ignore-item-p name ido-ignore-files t))
(defun ido-make-file-list (default)
;; Return the current list of files.
;; Currently visible files are put at the end of the list.
- ;; The hook `ido-make-file-list-hook' is run after the list has been
+ ;; The hook `ido-make-file-list-hook' is run after the list has been
;; 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))
(let ((default-directory ido-current-directory))
(ido-to-end ;; move ftp hosts and visited files to end
- (delq nil (mapcar
- (lambda (x) (if (or (string-match "..:\\'" x)
+ (delq nil (mapcar
+ (lambda (x) (if (or (string-match "..:\\'" x)
(and (not (ido-final-slash x))
(get-file-buffer x))) x))
ido-temp-list))))
(ido-to-end ;; move . files to end
- (delq nil (mapcar
+ (delq nil (mapcar
(lambda (x) (if (string-equal (substring x 0 1) ".") x))
ido-temp-list)))
(if (and default (member default ido-temp-list))
(setcdr l nil)
(nconc k ido-temp-list)
(setq ido-temp-list k)))
- (setq ido-temp-list
+ (setq ido-temp-list
(delete default ido-temp-list))
- (setq ido-temp-list
+ (setq ido-temp-list
(cons default ido-temp-list))))
(when ido-show-dot-for-dired
(setq ido-temp-list (delete "." ido-temp-list))
;; Return list of non-ignored subdirs in DIR
;; If MERGED is non-nil, each subdir is cons'ed with DIR
(and (or (ido-is-tramp-root dir) (file-directory-p dir))
- (delq nil
+ (delq nil
(mapcar
(lambda (name)
(and (ido-final-slash name) (not (ido-ignore-item-p name ido-ignore-directories))
(defun ido-make-dir-list (default)
;; Return the current list of directories.
- ;; The hook `ido-make-dir-list-hook' is run after the list has been
+ ;; The hook `ido-make-dir-list-hook' is run after the list has been
;; 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))
(ido-to-end ;; move . files to end
- (delq nil (mapcar
+ (delq nil (mapcar
(lambda (x) (if (string-equal (substring x 0 1) ".") x))
ido-temp-list)))
(if (and default (member default ido-temp-list))
(setcdr l nil)
(nconc k ido-temp-list)
(setq ido-temp-list k)))
- (setq ido-temp-list
+ (setq ido-temp-list
(delete default ido-temp-list))
- (setq ido-temp-list
+ (setq ido-temp-list
(cons default ido-temp-list))))
(setq ido-temp-list (delete "." ido-temp-list))
(setq ido-temp-list (cons "." ido-temp-list))
;; `ido-all-frames'.
(let ((ido-bufs-in-frame nil))
(walk-windows 'ido-get-bufname nil
- (if current
+ (if current
nil
ido-all-frames))
ido-bufs-in-frame))
(setq matches (cons item matches)))))
items))
matches))
-
+
(defun ido-set-matches ()
;; Set `ido-matches' to the list of items matching prompt
(when ido-rescan
(setq ido-matches (ido-set-matches1 (reverse ido-cur-list) (not ido-rotate))
ido-rotate nil)))
-
+
(defun ido-ignore-item-p (name re-list &optional ignore-ext)
;; Return t if the buffer or file NAME should be ignored.
(or (member name ido-ignore-item-temp-list)
(let ((data (match-data))
(ext-list (and ignore-ext ido-ignore-extensions
completion-ignored-extensions))
- ignorep nextstr
+ ignorep nextstr
(flen (length name)) slen)
(while ext-list
(setq nextstr (car ext-list))
(defun ido-word-matching-substring (word)
;; Return part of WORD before 1st match to `ido-change-word-sub'.
;; If `ido-change-word-sub' cannot be found in WORD, return nil.
- (let ((case-fold-search ido-case-fold))
+ (let ((case-fold-search ido-case-fold))
(let ((m (string-match ido-change-word-sub (ido-name word))))
(if m
(substring (ido-name word) m)
(let ((f 'display-completion-list))
(funcall f completion-list
:help-string "ido "
- :activate-callback
+ :activate-callback
'(lambda (x y z) (message "doesn't work yet, sorry!"))))
;; else running Emacs
;;(add-hook 'completion-setup-hook 'completion-setup-function)
;; Check if buffer still exists.
(if (get-buffer buf)
;; buffer couldn't be killed.
- (setq ido-rescan t)
+ (setq ido-rescan t)
;; else buffer was killed so remove name from list.
(setq ido-cur-list (delq buf ido-cur-list))))))
;; Check if file still exists.
(if (file-exists-p file)
;; file could not be deleted
- (setq ido-rescan t)
+ (setq ido-rescan t)
;; else file was killed so remove name from list.
(setq ido-cur-list (delq (car ido-matches) ido-cur-list))))))
\\[ido-next-match] Put the first element at the end of the list.
\\[ido-prev-match] Put the last element at the start of the list.
-\\[ido-complete] Complete a common suffix to the current string that
+\\[ido-complete] Complete a common suffix to the current string that
matches all buffers. If there is only one match, select that buffer.
If there is no common suffix, show a list of all matching buffers
in a separate window.
\\[ido-next-match] Put the first element at the end of the list.
\\[ido-prev-match] Put the last element at the start of the list.
-\\[ido-complete] Complete a common suffix to the current string that
+\\[ido-complete] Complete a common suffix to the current string that
matches all files. If there is only one match, select that file.
If there is no common suffix, show a list of all matching files
in a separate window.
(ido-work-directory-match-only nil)
(ido-ignore-files (cons "[^/]\\'" ido-ignore-files))
(ido-report-no-match nil)
+ (ido-confirm-unique-completion t)
(ido-auto-merge-work-directories-length -1))
(ido-file-internal 'write 'write-file nil "Write file: ")))
((ido-final-slash contents) ;; xxx/
(ido-trace "final slash" contents)
- (cond
+ (cond
((string-equal contents "~/")
(ido-set-current-home)
(setq refresh t))
(ido-set-current-directory (file-name-directory contents))
(setq refresh t))
((string-equal (substring contents -2 -1) "/")
- (ido-set-current-directory
+ (ido-set-current-directory
(if (memq system-type '(windows-nt ms-dos))
(expand-file-name "/" ido-current-directory)
"/"))
(setq refresh t))
+ ((and ido-directory-nonreadable
+ (file-directory-p (concat ido-current-directory (file-name-directory contents))))
+ (ido-set-current-directory
+ (concat ido-current-directory (file-name-directory contents)))
+ (setq refresh t))
(t
(ido-trace "try single dir")
(setq try-single-dir-match t))))
(or try-single-dir-match
(eq ido-enter-single-matching-directory t)))
(ido-trace "single match" (car ido-matches))
- (ido-set-current-directory
+ (ido-set-current-directory
(concat ido-current-directory (car ido-matches)))
(setq ido-exit 'refresh)
(exit-minibuffer))
(when (and (not ido-matches)
+ (not ido-directory-nonreadable)
;; ido-rescan ?
ido-process-ignore-lists
ido-ignored-list)
(memq ido-cur-item '(file dir))
(not (ido-is-root-directory))
(> (length contents) 1)
- (not (string-match "[$]" contents)))
+ (not (string-match "[$]" contents))
+ (not ido-directory-nonreadable))
(ido-trace "merge?")
(if ido-use-merged-list
(ido-undo-merge-work-directory contents nil)
(ido-trace "\n*start timer*")
(setq ido-auto-merge-timer
(run-with-timer ido-auto-merge-delay-time nil 'ido-initiate-auto-merge (current-buffer))))))
-
+
(setq ido-rescan t)
- (if (and ido-use-merged-list
+ (if (and ido-use-merged-list
ido-matches
(not (string-equal (car (cdr (car ido-matches))) ido-current-directory)))
(progn
;; Insert the match-status information:
(ido-set-common-completion)
- (let ((inf (ido-completions
+ (let ((inf (ido-completions
contents
minibuffer-completion-table
minibuffer-completion-predicate
(defun ido-completions (name candidates predicate require-match)
;; Return the string that is displayed after the user's text.
;; Modified from `icomplete-completions'.
-
+
(let* ((comps ido-matches)
(ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
ido-merged-indicator))
(if (and ind ido-use-faces)
(put-text-property 0 1 'face 'ido-indicator-face ind))
-
+
(if (and ido-use-faces comps)
(let* ((fn (ido-name (car comps)))
(ln (length fn)))
(setq comps (cons first (cdr comps)))))
(cond ((null comps)
- (if ido-report-no-match
- (nth 6 ido-decorations) ;; [No Match]
- ""))
+ (cond
+ (ido-directory-nonreadable
+ (or (nth 8 ido-decorations) " [Not readable]"))
+ (ido-report-no-match
+ (nth 6 ido-decorations)) ;; [No match]
+ (t "")))
((null (cdr comps)) ;one match
(concat (if (> (length (ido-name (car comps))) (length name))
(let* ((items (if (> ido-max-prospects 0) (1+ ido-max-prospects) 999))
(alternatives
(apply
- #'concat
+ #'concat
(cdr (apply
#'nconc
(mapcar
(defun ido-minibuffer-setup ()
"Minibuffer setup hook for `ido'."
;; Copied from `icomplete-minibuffer-setup-hook'.
- (when (and (boundp 'ido-completing-read)
+ (when (and (boundp 'ido-completing-read)
(or (featurep 'xemacs)
(= ido-use-mycompletion-depth (minibuffer-depth))))
(add-hook 'pre-command-hook 'ido-tidy nil t)
(= ido-use-mycompletion-depth (minibuffer-depth)))
(if (and (boundp 'ido-eoinput)
ido-eoinput)
-
+
(if (> ido-eoinput (point-max))
;; Oops, got rug pulled out from under us - reinit:
(setq ido-eoinput (point-max))
(let ((buffer-undo-list t))
(delete-region ido-eoinput (point-max))))
-
+
;; Reestablish the local variable 'cause minibuffer-setup is weird:
(make-local-variable 'ido-eoinput)
(setq ido-eoinput 1))))
;; This is an example function which can be hooked on to
;; `ido-make-buffer-list-hook'. Any buffer matching the regexps
;; `Summary' or `output\*$'are put to the end of the list.
- (let ((summaries (delq nil (mapcar
- (lambda (x)
- (if (or
+ (let ((summaries (delq nil (mapcar
+ (lambda (x)
+ (if (or
(string-match "Summary" x)
(string-match "output\\*\\'" x))
x))
;;; Helper functions for other programs
+(put 'dired-do-rename 'ido 'ignore)
+
;;;###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.
See `read-file-name' for additional parameters."
(cond
((or (eq predicate 'file-directory-p)
+ (eq (get this-command 'ido) 'dir)
(memq this-command ido-read-file-name-as-directory-commands))
(ido-read-directory-name prompt dir default-filename mustmatch initial))
- ((and (not (memq this-command ido-read-file-name-non-ido))
+ ((and (not (eq (get this-command 'ido) 'ignore))
+ (not (memq this-command ido-read-file-name-non-ido))
(or (null predicate) (eq predicate 'file-exists-p)))
- (let (filename
- ido-saved-vc-mt
- (vc-master-templates (and (boundp 'vc-master-templates) vc-master-templates))
- (ido-current-directory (expand-file-name (or dir default-directory)))
- (ido-work-directory-index -1)
- (ido-work-file-index -1)
- (ido-find-literal nil))
+ (let* (filename
+ ido-saved-vc-hb
+ (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-work-directory-index -1)
+ (ido-work-file-index -1)
+ (ido-find-literal nil))
(setq filename
(ido-read-internal 'file prompt 'ido-file-history default-filename mustmatch initial))
(if filename
(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."
- (let (filename
- ido-saved-vc-mt
- (ido-current-directory (expand-file-name (or dir default-directory)))
- (ido-work-directory-index -1)
- (ido-work-file-index -1))
+ (let* (filename
+ ido-saved-vc-hb
+ (ido-current-directory (ido-expand-directory dir))
+ (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
+ (ido-work-directory-index -1)
+ (ido-work-file-index -1))
(setq filename
(ido-read-internal 'dir prompt 'ido-file-history default-dirname mustmatch initial))
(if filename
ido-current-directory
(concat ido-current-directory filename)))))
+;;; arch-tag: b63a3500-1735-41bd-8a01-05373f0864da
;;; ido.el ends here