.emacs.d/lisp/init-completion.el

;;; init-completion.el --- completion config  -*- lexical-binding: t -*-

;;; Commentary:

;;; Code:

;; vertico，minibuffer补全
(use-package vertico
  :hook
  (after-init . vertico-mode))

;; orderless，模糊搜索
(use-package orderless
  :custom
  (completion-styles '(orderless basic)))

;; marginalia，命令注释
(use-package marginalia
  :hook
  (after-init . marginalia-mode))

;; consult，搜索与导航
(use-package consult
  :config
  ;; set locate arguments
  (cond
   (*is-windows*
    (setq consult-locate-args (encode-coding-string "es.exe -i -p -r" 'gbk)
	  consult-ripgrep-args (encode-coding-string
				"rg --null --line-buffered --color=never --max-columns=1000 --path-separator / --smart-case --no-heading --line-number"
				'gbk))
    (add-to-list 'process-coding-system-alist '("es" gbk . gbk)))
   (*is-mac*
    (setq consult-locate-args "mdfind -name"))
   (*is-linux*
    (setq consult-locate-args "plocate --basename --ignore-case")))

  (define-key consult-narrow-map (vconcat consult-narrow-key "?") #'consult-narrow-help)
  (setq consult-narrow-key "<")

  ;; set some buffer filter
  (setq consult-buffer-filter
	(cl-union consult-buffer-filter
		  '("^\\*dirvish"
		    "^PREVIEW"
		    "^\\*helpful"
		    "^\\*Help"
		    "Diff"
		    "straight"
		    "\\*Messages\\*"
		    "\\*Chinese-word-segmentation\\*"
		    "\\*gptel-reasoning\\*"
		    "\\*gptel-log\\*")
		  :test 'equal)))

;; embark，快捷指令
(use-package embark
  :commands
  embark-prefix-help-command
  :init
  (setq prefix-help-command 'embark-prefix-help-command)
  :config
  (defun my-embark-preview ()
    "Previews candidate in vertico buffer, unless it's a consult command."
    (interactive)
    (unless (bound-and-true-p consult--preview-function)
      (save-selected-window
        (let ((embark-quit-after-action nil))
          (embark-dwim)))))

  (add-to-list 'display-buffer-alist
               '("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
                 nil
                 (window-parameters (mode-line-format . none))))

  (with-no-warnings
    (with-eval-after-load 'which-key
      (defun embark-which-key-indicator ()
        "An embark indicator that displays keymaps using which-key.
The which-key help message will show the type and value of the
current target followed by an ellipsis if there are further
targets."
        (lambda (&optional keymap targets prefix)
          (if (null keymap)
              (which-key--hide-popup-ignore-command)
            (which-key--show-keymap
             (if (eq (plist-get (car targets) :type) 'embark-become)
                 "Become"
               (format "Act on %s '%s'%s"
                       (plist-get (car targets) :type)
                       (embark--truncate-target (plist-get (car targets) :target))
                       (if (cdr targets) "…" "")))
             (if prefix
                 (pcase (lookup-key keymap prefix 'accept-default)
                   ((and (pred keymapp) km) km)
                   (_ (key-binding prefix 'accept-default)))
               keymap)
             nil nil t (lambda (binding)
                         (not (string-suffix-p "-argument" (cdr binding))))))))

      (setq embark-indicators
            '(embark-which-key-indicator
              embark-highlight-indicator
              embark-isearch-highlight-indicator))

      (defun embark-hide-which-key-indicator (fn &rest args)
        "Hide the which-key indicator immediately when using the completing-read prompter."
        (which-key--hide-popup-ignore-command)
        (let ((embark-indicators
               (remq #'embark-which-key-indicator embark-indicators)))
          (apply fn args)))

      (advice-add #'embark-completing-read-prompter
                  :around #'embark-hide-which-key-indicator))))

;; embark-consult
(use-package embark-consult)

;; eglot
(use-package eglot
  :config
  (setq eglot-send-changes-idle-time 0.25)
  (add-to-list 'eglot-server-programs
               '(scheme-mode . ("guile-lsp-server")))

  ;; 在scheme模式禁用eglot补全，保留其他功能
  (add-hook 'eglot-managed-mode-hook
            (lambda ()
              (when (derived-mode-p 'scheme-mode)
		(setq-local completion-at-point-functions
                            (remq 'eglot-completion-at-point
                                  completion-at-point-functions))))))

;; corfu
(use-package corfu
  :autoload
  (corfu-quit consult-completion-in-region)
  :bind
  (:map corfu-map
	("M-d" . corfu-popupinfo-documentation))
  :custom
  (corfu-auto t)
  (corfu-auto-prefix 2)
  (corfu-count 12)
  (corfu-preview-current nil)
  (corfu-on-exact-match nil)
  (corfu-auto-delay 0.2)
  (corfu-popupinfo-delay '(0.4 . 0.2))
  (global-corfu-modes '((not erc-mode
			     circe-mode
			     help-mode
			     gud-mode
			     vterm-mode)
                        t))
  :hook
  (after-init . global-corfu-mode)
  (after-init . corfu-popupinfo-mode)
  (after-init . corfu-history-mode)
  :config
  ;;Quit completion before saving
  (add-hook 'before-save-hook #'corfu-quit)
  (add-hook 'eshell-mode-hook
          (lambda ()
            (setq-local corfu-auto nil)
            (local-set-key (kbd "TAB") 'completion-at-point)))
  :bind
  (:map corfu-map
	("RET" . nil)))

(if (not (and (display-graphic-p)
              (>= emacs-major-version 31)))
    (use-package corfu-terminal
      :hook
      (after-init . corfu-terminal-mode)))

(use-package emacs
  :custom
  (tab-always-indent 'complete)

  ;; Emacs 30 and newer: Disable Ispell completion function.
  ;; Try `cape-dict' as an alternative.
  (text-mode-ispell-word-completion nil)

  ;; Hide commands in M-x which do not apply to the current mode.  Corfu
  ;; commands are hidden, since they are not used via M-x. This setting is
  ;; useful beyond Corfu.
  (read-extended-command-predicate #'command-completion-default-include-p))

;; cape
(use-package cape
  :commands (cape-file cape-elisp-block cape-keyword)
  :autoload (cape-wrap-noninterruptible cape-wrap-nonexclusive cape-wrap-buster)
  :autoload (cape-wrap-silent)
  :init
  ;; (add-to-list 'completion-at-point-functions #'cape-dabbrev)
  (add-to-list 'completion-at-point-functions #'cape-file)
  (add-to-list 'completion-at-point-functions #'cape-elisp-block)
  (add-to-list 'completion-at-point-functions #'cape-keyword)
  ;; (add-to-list 'completion-at-point-functions #'cape-abbrev)

  ;; Make these capfs composable.
  (advice-add 'comint-completion-at-point :around #'cape-wrap-nonexclusive)
  (advice-add 'eglot-completion-at-point :around #'cape-wrap-buster)
  (advice-add 'eglot-completion-at-point :around #'cape-wrap-nonexclusive)
  (advice-add 'pcomplete-completions-at-point :around #'cape-wrap-nonexclusive))

(provide 'init-completion)

;;; init-completion.el ends here