[elpa] externals/cape 67c3b75e2a 039/146: Refactor dabbrev, simplify

[ELPA Syncer]

branch: externals/cape
commit 67c3b75e2a14c55fa0a4e943f882075a525fd7c9
Author: Daniel Mendler <mail@daniel-mendler.de>
Commit: Daniel Mendler <mail@daniel-mendler.de>

    Refactor dabbrev, simplify
---
 cape.el | 71 ++++++++++++++++++++++++++++++-----------------------------------
 1 file changed, 33 insertions(+), 38 deletions(-)

diff --git a/cape.el b/cape.el
index 62ff59c5c5..c13fa59ec9 100644
--- a/cape.el
+++ b/cape.el
@@ -48,6 +48,10 @@
   "Company asynchronous busy waiting time."
   :type 'float)
 
+(defcustom cape-dabbrev-min-length 4
+  "Minimum length of dabbrev expansions."
+  :type 'integer)
+
 (defcustom cape-keywords
   ;; This variable was taken from company-keywords.el.
   ;; Please contribute corrections or additions to both Cape and Company.
@@ -342,59 +346,50 @@
   (interactive)
   (cape--complete-in-region 'symbol obarray cape--symbol-properties))
 
+(defun cape--cached-table (beg end cmp fun)
+  "Create caching completion table.
+BEG and END are the input bounds.
+CMP is the input comparison function, see `cape--input-changed-p'.
+FUN is the function which computes the candidates."
+  (let ((input 'init)
+        (beg (copy-marker beg))
+        (end (copy-marker end t))
+        (table nil))
+    (lambda (str pred action)
+      (let ((new-input (buffer-substring-no-properties beg end)))
+        (when (or (eq input 'init) (cape--input-changed-p input new-input cmp))
+          (setq table (funcall fun new-input) input new-input)))
+      (complete-with-action action table str pred))))
+
 (defvar cape--dabbrev-properties
   (list :annotation-function (lambda (_) " Dabbrev")
         :company-kind (lambda (_) 'text)))
 
 (defvar dabbrev-check-all-buffers)
 (defvar dabbrev-check-other-buffers)
-(declare-function dabbrev--abbrev-at-point "dabbrev")
 (declare-function dabbrev--ignore-case-p "dabbrev")
 (declare-function dabbrev--find-all-expansions "dabbrev")
 (declare-function dabbrev--reset-global-variables "dabbrev")
 
 ;;;###autoload
 (defun cape-dabbrev-capf ()
-  "Dabbrev completion-at-point-function."
-  (require 'dabbrev)
+  "Ispell completion-at-point-function."
+  (when-let (bounds (bounds-of-thing-at-point 'word))
+    `(,(car bounds) ,(cdr bounds)
+      ,(cape--cached-table (car bounds) (cdr bounds) 'prefix 
#'cape--dabbrev-expansions)
+      :exclusive no
+      ,@cape--dabbrev-properties)))
+
+(defun cape--dabbrev-expansions (word)
+  "Find all dabbrev expansions for WORD."
   (let ((dabbrev-check-all-buffers nil)
         (dabbrev-check-other-buffers nil))
     (dabbrev--reset-global-variables))
-  (let ((abbrev (ignore-errors (dabbrev--abbrev-at-point))))
-    (when (and abbrev (not (string-match-p "[ \t\n]" abbrev)))
-      (pcase ;; Interruptible scanning
-          (while-no-input
-            (let ((inhibit-message t)
-                  (message-log-max nil))
-              (or (dabbrev--find-all-expansions
-                   abbrev (dabbrev--ignore-case-p abbrev))
-                  t)))
-        ('nil (keyboard-quit))
-        ('t nil)
-        (words
-         ;; Ignore completions which are too short
-         (let ((min-len (+ 4 (length abbrev))))
-           (setq words (seq-remove (lambda (x) (< (length x) min-len)) words)))
-         (when words
-           (let ((beg (progn (search-backward abbrev) (point)))
-                 (end (progn (search-forward abbrev) (point))))
-             (unless (string-match-p "\n" (buffer-substring beg end))
-               `(,beg ,end ,words :exclusive no 
,@cape--dabbrev-properties)))))))))
-
-(defun cape--cached-table (beg end cmp fun)
-  "Create caching completion table.
-BEG and END are the input bounds.
-CMP is the input comparison function, see `cape--input-changed-p'.
-FUN is the function which computes the candidates."
-  (let ((input 'init)
-        (beg (copy-marker beg))
-        (end (copy-marker end t))
-        (table nil))
-    (lambda (str pred action)
-      (let ((new-input (buffer-substring-no-properties beg end)))
-        (when (or (eq input 'init) (cape--input-changed-p input new-input cmp))
-          (setq table (funcall fun new-input) input new-input)))
-      (complete-with-action action table str pred))))
+  (let* ((inhibit-message t)
+         (message-log-max nil)
+         (min-len (+ cape-dabbrev-min-length (length word)))
+         (words (dabbrev--find-all-expansions word (dabbrev--ignore-case-p 
word))))
+    (cl-loop for w in words if (>= (length w) min-len) collect w)))
 
 (defvar cape--ispell-properties
   (list :annotation-function (lambda (_) " Ispell")