[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Updating *Completions* as you type

From: sbaugh
Subject: Re: Updating *Completions* as you type
Date: Sun, 19 Nov 2023 19:22:49 +0000 (UTC)
User-agent: Gnus/5.13 (Gnus v5.13)

Juri Linkov <juri@linkov.net> writes:
>> How about this?
> Looks good.
>> +             (read-buffer-sort minibuffer
>> +                               (choice (const :tag "completions-sort 
>> controls sorting" nil)
>> +                                       (const :tag "sort matching 
>> buffer-list" buffer-list))
>> +                               "30.1")
> Shouldn't 'read-buffer-sort' support other choices from 'completions-sort'?
> Your new choice 'historical' would sort buffers by the order of 'M-p'
> the same way as 'buffer-list' will sort buffers by the order of 'M-n'.
> Also 'alphabetical' would be useful for 'C-x b' when 'completions-sort'
> was customized to something else.

Finally got to it, I've added that in this patch (which combines both
the read-buffer-sort and completions-sort changes).

The nice reusable part is that the new minibuffer-sort-by-history and
minibuffer-sort-alphabetically should work for any completion table.  So
it will be easy to just add options for different completion tables,
e.g. read-file-name-sort, and they can just use those pre-existing

This does require adding the new dynamic variable
minibuffer-completion-base which maybe should go in some other place, or
could be derived from some other variable - I'm not sure.  Possibly it's
fine as I did it.

>From 5e898c3ef323971af89b80fe37d94be0bf29443f Mon Sep 17 00:00:00 2001
From: Spencer Baugh <sbaugh@catern.com>
Date: Tue, 17 Oct 2023 09:09:55 -0400
Subject: [PATCH] Add read-buffer-sort to customize how read-buffer sorts

Add the ability to customize how read-buffer (actually
internal-complete-buffer) sorts the buffer completion candidates.

Also add minibuffer-sort-alphabetically and minibuffer-sort-by-history
to provide some reasonable options for read-buffer-sort.

And add support for them to completions-sort, too, as a simple change.

* lisp/minibuffer.el (completions-sort): Document 'historical option.
(minibuffer-completion-help): Support 'historical option.
(minibuffer-completion-base, minibuffer-sort-by-history): Add.
* lisp/cus-start.el (standard): Add customization information for
* src/minibuf.c (Finternal_complete_buffer): Use read-buffer-sort.
(syms_of_minibuf): Add read-buffer-sort.
 lisp/cus-start.el  |  7 ++++++
 lisp/minibuffer.el | 63 +++++++++++++++++++++++++++++++++++++++++-----
 src/minibuf.c      | 32 ++++++++++++++++++++---
 3 files changed, 93 insertions(+), 9 deletions(-)

diff --git a/lisp/cus-start.el b/lisp/cus-start.el
index 6d83aaf4d14..40bc4078d77 100644
--- a/lisp/cus-start.el
+++ b/lisp/cus-start.el
@@ -441,6 +441,13 @@ minibuffer-prompt-properties--setter
             (read-buffer-function minibuffer
                                   (choice (const nil)
+             (read-buffer-sort minibuffer
+                               (choice (const :tag "completions-sort controls 
sorting" nil)
+                                       (const :tag "sort matching buffer-list" 
+                                       (const :tag "sort alphabetically" 
+                                       (const :tag "sort historically" 
+                                       (function :tag "User-defined function"))
+                               "30.1")
             ;; msdos.c
             (dos-unsupported-char-glyph display integer)
             ;; nsterm.m
diff --git a/lisp/minibuffer.el b/lisp/minibuffer.el
index 026613c9eb2..49086ff6eff 100644
--- a/lisp/minibuffer.el
+++ b/lisp/minibuffer.el
@@ -1307,14 +1307,26 @@ completion-cycle-threshold
 (defcustom completions-sort 'alphabetical
   "Sort candidates in the *Completions* buffer.
-The value can be nil to disable sorting, `alphabetical' for
-alphabetical sorting or a custom sorting function.  The sorting
-function takes and returns a list of completion candidate
+Candidate completions in the *Completions* are sorted depending
+on the value.
+If nil, sorting is disabled.
+If `alphabetical', candidates are sorted by
+If `historical', candidates are sorted by
+If a function, the function is called to sort the candidates.
+The sorting function takes and returns a list of completion
+candidate strings.
+If the completion-specific metadata provides a
+`display-sort-function', that is used instead and this value is
   :type '(choice (const :tag "No sorting" nil)
                  (const :tag "Alphabetical sorting" alphabetical)
+                 (const :tag "Historical sorting" historical)
                  (function :tag "Custom function"))
-  :version "29.1")
+  :version "30.1")
 (defcustom completions-group nil
   "Enable grouping of completion candidates in the *Completions* buffer.
@@ -1640,6 +1652,43 @@ minibuffer--sort-preprocess-history
                      (substring c base-size)))
+(defun minibuffer-sort-alphabetically (completions)
+  "Sort COMPLETIONS alphabetically.
+COMPLETIONS are sorted alphabetically by `string-lessp'.
+This is a suitable function to use for `completions-sort' or to
+include as `display-sort-function' in completion metadata."
+  (sort completions #'string-lessp))
+(defvar minibuffer-completion-base nil
+  "The base for the current completion.
+This is the part of the current minibuffer input which is not
+being completed on.  This is primarily relevant for file names,
+where this is the directory component of the file name.")
+(defun minibuffer-sort-by-history (completions)
+  "Sort COMPLETIONS by their position in `minibuffer-history-variable'.
+COMPLETIONS are sorted first by `minibuffer-sort-alphbetically',
+then any elements occuring in the minibuffer history list are
+moved to the front based on the order they occur in the history.
+If a history variable hasn't been specified for this call of
+`completing-read', COMPLETIONS are sorted only by
+This is a suitable function to use for `completions-sort' or to
+include as `display-sort-function' in completion metadata."
+  (let ((alphabetized (sort completions #'string-lessp)))
+    ;; Only use history when it's specific to these completions.
+    (if (eq minibuffer-history-variable
+            (default-value minibuffer-history-variable))
+        alphabetized
+      (minibuffer--sort-by-position
+       (minibuffer--sort-preprocess-history minibuffer-completion-base)
+       alphabetized))))
 (defun minibuffer--group-by (group-fun sort-fun elems)
   "Group ELEMS by GROUP-FUN and sort groups by SORT-FUN."
   (let ((groups))
@@ -2470,6 +2519,7 @@ minibuffer-completion-help
       (let* ((last (last completions))
              (base-size (or (cdr last) 0))
              (prefix (unless (zerop base-size) (substring string 0 base-size)))
+             (minibuffer-completion-base (substring string 0 base-size))
              (base-prefix (buffer-substring (minibuffer--completion-prompt-end)
                                             (+ start base-size)))
@@ -2540,7 +2590,8 @@ minibuffer-completion-help
                                             (funcall sort-fun completions)
                                           (pcase completions-sort
                                             ('nil completions)
-                                            ('alphabetical (sort completions 
+                                            ('alphabetical 
(minibuffer-sort-alphabetically completions))
+                                            ('historical 
(minibuffer-sort-by-history completions))
                                             (_ (funcall completions-sort 
                       ;; After sorting, group the candidates using the
diff --git a/src/minibuf.c b/src/minibuf.c
index 58adde1bf66..04551afeb79 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -2186,9 +2186,15 @@ DEFUN ("internal-complete-buffer", 
Finternal_complete_buffer, Sinternal_complete
   else if (EQ (flag, Qlambda))
     return Ftest_completion (string, Vbuffer_alist, predicate);
   else if (EQ (flag, Qmetadata))
-    return list3 (Qmetadata,
-                  Fcons (Qcategory, Qbuffer),
-                  Fcons (Qcycle_sort_function, Qidentity));
+    {
+      Lisp_Object res = list2 (Fcons (Qcategory, Qbuffer),
+                              Fcons (Qcycle_sort_function, Qidentity));
+      if (EQ (Vread_buffer_sort, Qbuffer_list))
+       res = Fcons (Fcons (Qdisplay_sort_function, Qidentity), res);
+      else if (FUNCTIONP (Vread_buffer_sort))
+       res = Fcons (Fcons (Qdisplay_sort_function, Vread_buffer_sort), res);
+      return Fcons (Qmetadata, res);
+    }
     return Qnil;
@@ -2323,6 +2329,7 @@ syms_of_minibuf (void)
   DEFSYM (Qcase_fold_search, "case-fold-search");
   DEFSYM (Qmetadata, "metadata");
   DEFSYM (Qcycle_sort_function, "cycle-sort-function");
+  DEFSYM (Qdisplay_sort_function, "display-sort-function");
   /* A frame parameter.  */
   DEFSYM (Qminibuffer_exit, "minibuffer-exit");
@@ -2522,6 +2529,25 @@ syms_of_minibuf (void)
 the minibuffer.  However, if `minibuffer-restore-windows' is present
 in `minibuffer-exit-hook', exiting the minibuffer will remove the window
 showing the *Completions* buffer, if any.  */);
+  DEFVAR_LISP ("read-buffer-sort", Vread_buffer_sort,
+              doc: /* Non-nil means sort completions in `read-buffer'.
+If this is nil (the default), completions in `read-buffer' are sorted
+according to `completions-sort'.
+If this is `buffer-list', completions are sorted to match the order of
+If a function, the function is called to sort the candidates.  Some
+possible values are `minibuffer-sort-alphabetically' and
+This variable only affects the default `read-buffer', so if
+`read-buffer-function' is set to a function which does not use
+`internal-complete-buffer', this variable will have no effect.*/);
+  Vread_buffer_sort = Qnil;
   read_minibuffer_restore_windows = true;
   defsubr (&Sactive_minibuffer_window);

reply via email to

[Prev in Thread] Current Thread [Next in Thread]