;;; minibuffer.el --- Minibuffer completion functions
-;; Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
;;; Todo:
-;; - make partial-complete-mode obsolete:
+;; - extend `boundaries' to provide various other meta-data about the
+;; output of `all-completions':
+;; - preferred sorting order when displayed in *Completions*.
+;; - annotations/text-properties to add when displayed in *Completions*.
+;; - quoting/unquoting (so we can complete files names with envvars
+;; and backslashes, and all-completion can list names without
+;; quoting backslashes and dollars).
+;; - indicate how to turn all-completion's output into
+;; try-completion's output: e.g. completion-ignored-extensions.
+;; maybe that could be merged with the "quote" operation above.
+;; - completion hook to run when the completion is
+;; selected/inserted (maybe this should be provided some other
+;; way, e.g. as text-property, so `try-completion can also return it?)
+;; both for when it's inserted via TAB or via choose-completion.
+;; - indicate that `all-completions' doesn't do prefix-completion
+;; but just returns some list that relates in some other way to
+;; the provided string (as is the case in filecache.el), in which
+;; case partial-completion (for example) doesn't make any sense
+;; and neither does the completions-first-difference highlight.
+
+;; - make partial-completion-mode obsolete:
;; - (?) <foo.h> style completion for file names.
;; This can't be done identically just by tweaking completion,
;; because partial-completion-mode's behavior is to expand <string.h>
(defconst completion-styles-alist
'((emacs21
completion-emacs21-try-completion completion-emacs21-all-completions
- "Simple prefix-based completion.")
+ "Simple prefix-based completion.
+I.e. when completing \"foo_bar\" (where _ is the position of point),
+it will consider all completions candidates matching the glob
+pattern \"foobar*\".")
(emacs22
completion-emacs22-try-completion completion-emacs22-all-completions
- "Prefix completion that only operates on the text before point.")
+ "Prefix completion that only operates on the text before point.
+I.e. when completing \"foo_bar\" (where _ is the position of point),
+it will consider all completions candidates matching the glob
+pattern \"foo*\" and will add back \"bar\" to the end of it.")
(basic
completion-basic-try-completion completion-basic-all-completions
- "Completion of the prefix before point and the suffix after point.")
+ "Completion of the prefix before point and the suffix after point.
+I.e. when completing \"foo_bar\" (where _ is the position of point),
+it will consider all completions candidates matching the glob
+pattern \"foo*bar*\".")
(partial-completion
completion-pcm-try-completion completion-pcm-all-completions
"Completion of multiple words, each one taken as a prefix.
-E.g. M-x l-c-h can complete to list-command-history
-and C-x C-f /u/m/s to /usr/monnier/src.")
+I.e. when completing \"l-co_h\" (where _ is the position of point),
+it will consider all completions candidates matching the glob
+pattern \"l*-co*h*\".
+Furthermore, for completions that are done step by step in subfields,
+the method is applied to all the preceding fields that do not yet match.
+E.g. C-x C-f /u/mo/s TAB could complete to /usr/monnier/src.
+Additionally the user can use the char \"*\" as a glob pattern.")
(initials
completion-initials-try-completion completion-initials-all-completions
"Completion of acronyms and initialisms.
follow the calling convention of `completion-all-completions'),
and DOC describes the way this style of completion works.")
-(defcustom completion-styles '(basic partial-completion emacs22)
+(defcustom completion-styles
+ ;; First, use `basic' because prefix completion has been the standard
+ ;; for "ever" and works well in most cases, so using it first
+ ;; ensures that we obey previous behavior in most cases.
+ '(basic
+ ;; Then use `partial-completion' because it has proven to
+ ;; be a very convenient extension.
+ partial-completion
+ ;; Finally use `emacs22' so as to maintain (in many/most cases)
+ ;; the previous behavior that when completing "foobar" with point
+ ;; between "foo" and "bar" the completion try to complete "foo"
+ ;; and simply add "bar" to the end of the result.
+ emacs22)
"List of completion styles to use.
The available styles are listed in `completion-styles-alist'."
:type `(repeat (choice ,@(mapcar (lambda (x) (list 'const (car x)))
POINT is the position of point within STRING.
The return value is a list of completions and may contain the base-size
in the last `cdr'."
- ;; FIXME: We need to additionally return completion-extra-size (similar
- ;; to completion-base-size but for the text after point).
+ ;; FIXME: We need to additionally return the info needed for the
+ ;; second part of completion-base-position.
(completion--some (lambda (style)
(funcall (nth 2 (assq style completion-styles-alist))
string table pred point))
(if completions 2 0)
(if exact 1 0)))
+(defun completion--replace (beg end newtext)
+ "Replace the buffer text between BEG and END with NEWTEXT.
+Moves point to the end of the new text."
+ ;; This should be in subr.el.
+ ;; You'd think this is trivial to do, but details matter if you want
+ ;; to keep markers "at the right place" and be robust in the face of
+ ;; after-change-functions that may themselves modify the buffer.
+ (goto-char beg)
+ (insert newtext)
+ (delete-region (point) (+ (point) (- end beg))))
+
(defun completion--do-completion (&optional try-completion-function)
"Do the completion and return a summary of what happened.
M = completion was performed, the text was Modified.
string nil nil t))))
(unchanged (eq t (compare-strings completion nil nil
string nil nil nil))))
- (unless unchanged
-
- ;; Insert in minibuffer the chars we got.
+ (if unchanged
(goto-char end)
- (insert completion)
- (delete-region beg end))
- ;; Move point.
- (goto-char (+ beg comp-pos))
+ ;; Insert in minibuffer the chars we got.
+ (completion--replace beg end completion))
+ ;; Move point to its completion-mandated destination.
+ (forward-char (- comp-pos (length completion)))
(if (not (or unchanged completed))
;; The case of the string changed, but that's all. We're not sure
((test-completion (buffer-substring beg end)
minibuffer-completion-table
minibuffer-completion-predicate)
+ ;; FIXME: completion-ignore-case has various slightly
+ ;; incompatible meanings. E.g. it can reflect whether the user
+ ;; wants completion to pay attention to case, or whether the
+ ;; string will be used in a context where case is significant.
+ ;; E.g. usually try-completion should obey the first, whereas
+ ;; test-completion should obey the second.
(when completion-ignore-case
;; Fixup case of the field, if necessary.
(let* ((string (buffer-substring beg end))
string
minibuffer-completion-table
minibuffer-completion-predicate)))
- (when (and (stringp compl)
+ (when (and (stringp compl) (not (equal string compl))
;; If it weren't for this piece of paranoia, I'd replace
;; the whole thing with a call to do-completion.
;; This is important, e.g. when the current minibuffer's
(delete-region beg end))))
(exit-minibuffer))
- ((eq minibuffer-completion-confirm 'confirm)
+ ((memq minibuffer-completion-confirm '(confirm confirm-after-completion))
;; The user is permitted to exit with an input that's rejected
;; by test-completion, after confirming her choice.
- (if (eq last-command this-command)
+ (if (or (eq last-command this-command)
+ ;; For `confirm-after-completion' we only ask for confirmation
+ ;; if trying to exit immediately after typing TAB (this
+ ;; catches most minibuffer typos).
+ (and (eq minibuffer-completion-confirm 'confirm-after-completion)
+ (not (memq last-command minibuffer-confirm-exit-commands))))
(exit-minibuffer)
(minibuffer-message "Confirm")
nil))
- ((eq minibuffer-completion-confirm 'confirm-after-completion)
- ;; Similar to the above, but only if trying to exit immediately
- ;; after typing TAB (this catches most minibuffer typos).
- (if (memq last-command minibuffer-confirm-exit-commands)
- (progn (minibuffer-message "Confirm")
- nil)
- (exit-minibuffer)))
-
(t
;; Call do-completion, but ignore errors.
(case (condition-case nil
(exit-minibuffer))
(defvar completion-in-region-functions nil
- "Wrapper hook around `complete-in-region'.
+ "Wrapper hook around `completion-in-region'.
The functions on this special hook are called with 5 arguments:
NEXT-FUN START END COLLECTION PREDICATE.
NEXT-FUN is a function of four arguments (START END COLLECTION PREDICATE)
-that performs the default operation. The other four argument are like
-the ones passed to `complete-in-region'. The functions on this hook
+that performs the default operation. The other four arguments are like
+the ones passed to `completion-in-region'. The functions on this hook
are expected to perform completion on START..END using COLLECTION
and PREDICATE, either by calling NEXT-FUN or by doing it themselves.")
"Complete the text between START and END using COLLECTION.
Return nil if there is no valid completion, else t.
Point needs to be somewhere between START and END."
- ;; FIXME: some callers need to setup completion-ignore-case,
- ;; completion-ignored-extensions. The latter can be embedded in the
- ;; completion tables, but the first cannot (actually, maybe it should).
(assert (<= start (point)) (<= (point) end))
;; FIXME: undisplay the *Completions* buffer once the completion is done.
(with-wrapper-hook
(call-interactively 'minibuffer-complete)
(delete-overlay ol)))))
+(defvar completion-at-point-functions nil
+ "Special hook to find the completion table for the thing at point.
+It is called without any argument and should return either nil,
+or a function of no argument to perform completion (discouraged),
+or a list of the form (START END COLLECTION &rest PROPS) where
+ START and END delimit the entity to complete and should include point,
+ COLLECTION is the completion table to use to complete it, and
+ PROPS is a property list for additional information.
+Currently supported properties are:
+ `:predicate' a predicate that completion candidates need to satisfy.
+ `:annotation-function' the value to use for `completion-annotate-function'.")
+
+(defun completion-at-point ()
+ "Complete the thing at point according to local mode.
+This runs the hook `completion-at-point-functions' until a member returns
+non-nil."
+ (interactive)
+ (let ((res (run-hook-with-args-until-success
+ 'completion-at-point-functions)))
+ (cond
+ ((functionp res) (funcall res))
+ (res
+ (let* ((plist (nthcdr 3 res))
+ (start (nth 0 res))
+ (end (nth 1 res))
+ (completion-annotate-function
+ (or (plist-get plist :annotation-function)
+ completion-annotate-function)))
+ (completion-in-region start end (nth 2 res)
+ (plist-get plist :predicate)))))))
+
+;;; Key bindings.
+
+(define-obsolete-variable-alias 'minibuffer-local-must-match-filename-map
+ 'minibuffer-local-filename-must-match-map "23.1")
+
(let ((map minibuffer-local-map))
(define-key map "\C-g" 'abort-recursive-edit)
(define-key map "\r" 'exit-minibuffer)
;; substitute-in-file-name turns "fo-$TO-ba" into "fo-o/b-ba", there's
;; no way for us to return proper boundaries info, because the
;; boundary is not (yet) in `string'.
+ ;; FIXME: Actually there is a way to return correct boundaries info,
+ ;; at the condition of modifying the all-completions return accordingly.
(let ((start (length (file-name-directory string)))
(end (string-match-p "/" (cdr action))))
(list* 'boundaries start end)))
(defun completion-pcm--prepare-delim-re (delims)
(setq completion-pcm--delim-wild-regex (concat "[" delims "*]")))
-(defcustom completion-pcm-word-delimiters "-_. "
+(defcustom completion-pcm-word-delimiters "-_./: "
"A string of characters treated as word delimiters for completion.
Some arcane rules:
If `]' is in this string, it must come first.
(when completions
(let* ((re (completion-pcm--pattern->regex pattern '(point)))
(case-fold-search completion-ignore-case))
- ;; Remove base-size during mapcar, and add it back later.
(mapcar
(lambda (str)
;; Don't modify the string itself.
;; Complete /ums to /usr/monnier/src or lch to list-command-history.
(defun completion-initials-expand (str table pred)
- (unless (or (zerop (length str))
- (string-match completion-pcm--delim-wild-regex str))
- (let ((bounds (completion-boundaries str table pred "")))
+ (let ((bounds (completion-boundaries str table pred "")))
+ (unless (or (zerop (length str))
+ ;; Only check within the boundaries, since the
+ ;; boundary char (e.g. /) might be in delim-regexp.
+ (string-match completion-pcm--delim-wild-regex str
+ (car bounds)))
(if (zerop (car bounds))
(mapconcat 'string str "-")
;; If there's a boundary, it's trickier. The main use-case