company-fuzzy

Fuzzy matching for `company-mode'.

Pure elisp fuzzy completion for company-mode. This plugin search through all the buffer local company-backends and fuzzy search all candidates.

🏆 Features

• Work across all backends - Any backend that gives list of string should work.
• Only uses native elisp code - I personally don't prefer any external program unless is necessary.
• Combined all backends to one backend - Opposite to company-try-hard, hence all possible candidates will be shown in the auto-complete menu.

🧪 Differences from other alternatives

• company-ycmd
  • Uses ycmd as backend to provide functionalities.
  • Quite hard to config properly.
• company-flx
  • Uses library flx. (Optional for us)
  • Only works with capf backend currently.

💾 Quickstart

(use-package company-fuzzy
  :hook (company-mode . company-fuzzy-mode)
  :init
  (setq company-fuzzy-sorting-backend 'flx
        company-fuzzy-prefix-on-top nil
        company-fuzzy-trigger-symbols '("." "->" "<" "\"" "'" "@")))

🔧 Usage

You can enable it globally by adding this line to your config

(global-company-fuzzy-mode 1)

Or you can just enable it in any specific buffer/mode you want.

(company-fuzzy-mode 1)

Make sure you call either of these functions after all company-backends are set and config properly. Because this plugin will replace all backends to this minor mode specific backend (basically take all backends away, so this mode could combine all sources and do the fuzzy work).

🔍 Sorting/Scoring backend

There are multiple sorting algorithms for auto-completion. You can choose your own backend by customize company-fuzzy-sorting-backend variable like this.

(setq company-fuzzy-sorting-backend 'alphabetic)

Currently supports these values,

• none - Gives you the raw result.
• alphabetic - Sort in the alphabetic order. (VSCode)
• flex - Use library flex as matching engine.
• flx - Use library flx as matching engine. (Sublime Text)
• flx-rs - Use library flx-rs as matching engine. (Sublime Text)
• flxy - Use library flxy as matching engine.
• fuz-skim - Use library fuz.el's skim algorithm.
• fuz-clangd - Use library fuz.el's clangd algorithm.
• fuz-bin-skim - Use library fuz-bin's skim algorithm.
• fuz-bin-clangd - Use library fuz-bin's clangd algorithm.
• liquidmetal - Use library liquidmetal similar to Quicksilver algorithm.
• sublime-fuzzy - Use library sublime-fuzzy as matching engine. (Sublime Text)

Or implements your sorting algorithm yourself? Assgin the function to company-fuzzy-sorting-function variable like this.

(setq company-fuzzy-sorting-function (lambda (candidates)
                                       (message "%s" candidates)
                                       candidates))  ; Don't forget to return the candidaites!

🔍 Prefix On Top

If you wish the prefix matchs on top of all other selection, customize this variable to t like the line below.

(setq company-fuzzy-prefix-on-top t)

P.S. If you set company-fuzzy-sorting-backend to 'flx then you probably don't need this to be on because the flx scoring engine already take care of that!

🔍 For annotation

You can toggle company-fuzzy-show-annotation for showing annotation or not.

(setq company-fuzzy-show-annotation t)

You can also customize annotation using format variable.

• company-fuzzy-annotation-format => <%s>

🔍 Excluding

You can customize variable company-fuzzy-passthrough-backends to exclude some of the backends from polluting the fuzzy matching.

(setq company-fuzzy-passthrough-backends '(company-capf))

P.S. This is design to use with semantic backends, like lsp-mode (uses company-capf) , or eglot, etc.

💬 Details

Since company granted most control to users, every company backend developer has different method of implementing company backend. It is hard to manage all backends to one by varies of rules.

Recommended Settings

There are something that company design it weirdly, in order to make this plugin work smoothly I would recommend these company's variables to be set.

(use-package company
  :init
  (setq company-require-match nil            ; Don't require match, so you can still move your cursor as expected.
        company-tooltip-align-annotations t  ; Align annotation to the right side.
        company-eclim-auto-save nil          ; Stop eclim auto save.
        company-dabbrev-downcase nil)        ; No downcase when completion.
  :config
  ;; Enable downcase only when completing the completion.
  (defun jcs--company-complete-selection--advice-around (fn)
    "Advice execute around `company-complete-selection' command."
    (let ((company-dabbrev-downcase t))
      (call-interactively fn)))
  (advice-add 'company-complete-selection :around #'jcs--company-complete-selection--advice-around))

P.S. For the full configuration, you can check out my configuration here.

❓ FAQ

💫 Why is company-fuzzy not working?

Try to log out the company-backends and make sure company-fuzzy-all-other-backends is the only backend in your list. If it's not, enable company-fuzzy-mode to swap out all backends and hand it over to company-fuzzy to manage it.

(message "%s" company-backends)         ; '(company-fuzzy-all-other-backends)
(message "%s" company-fuzzy--backends)  ; .. backends has been handed over to `company-fuzzy`

💫 When should I call company-fuzzy-mode?

You should call company-fuzzy-mode after you have done configured variable company-backends.

(setq company-backends '(company-capf company-yasnippets)  ; configure backends

.. (other configuration)

(company-fuzzy-mode 1)                                     ; enable fuzzy matching at the very last

💫 What if I want to add backends to specific major-mode?

You can add any backends as long as you call company-fuzzy-mode at the very end of your mode hook. You can log out variable company-fuzzy--backends and see what backends are currently handled by company-fuzzy-mode!

Or, you can hack through by configuring variable company-fuzzye--backends directly but this is not recommended since after you disable company-fuzzy-mode it will not be restored back to company-backends. Unless you change it with variable company-fuzzy--recorded-backends simutamiously so it can be restored back to your company-backends' true form.

❗ UPDATE: You can now use the following functions to accomplish these tasks in a much elegant way:

(company-fuzzy-backend-add    'company-capf)
(company-fuzzy-backend-remove 'company-yasnippets)

💫 Why do some candidates aren't showing up?

This can cause by various reasons. The common causes are:

🔎 1. Cause by Semantic backend rules

company-fuzzy respects backends' rule. Meaning the candidates can be restricted by the backend you are using. For example,

(defvar my-variable)  ; You declare a variable

(my-vari.. )          ; but you are trying to use the variable as a function

The my-variable would not show up since the backend thinks it should be a function and not a variable.

🔎 2. Cause by completion-styles

Candidates are first filtered by Emacs built-on completion engine. Try tweaking the variable completion-styles with other possible options.

(setq completion-styles '(partial-completion))

Or hook up with the company's hooks:

(add-hook 'company-completion-started-hook
          (lambda ()
            (setq completion-styles '(partial-completion))))

(add-hook 'company-after-completion-hook
          (lambda ()
            ;; Revert `completion-styles' to original values
            (setq completion-styles ..)))

See Completion Alternatives for more information.

🔎 3. Scores lower than 0

Another cause would be the candidate has been eliminated by the scoring engine (it scores lower than 0); hence it would not be shown.

Best way to debug this, is to feed query and candidate to the scoring functions. The following example uses flx:

(flx-score "window-system" "win-sys")  ; return score and it's match data

Another example using the liquidmetal:

(liquidmetal-score "window-system" "win-sys")  ; return score

💫 Why are some variables not respected with special symbols? (@, :, etc)

company-fuzzy detects prefix depends on the Syntax Table . And those special symbols normally doesn't get treated as a whole prefix, hence you should see the completion get inserted incorrectly,

<!-- Try to complete `:link:` emoji -->
:lin

<!-- WRONG, the symbol `:` colon doesn't count as a prefix -->
::link:

How to solve this? You should configure your syntax table by doing something similar to

(add-hook 'markdown-mode-hook (lambda () (modify-syntax-entry ?: "w"))

See related issue #22 (ruby-mode with @ symbol).

🛠️ Contribute

If you would like to contribute to this project, you may either clone or make pull requests to this repository. Or you can clone the project and establish your branch of this tool. Any methods are welcome!

🔬 Development

To run the test locally, you will need the following tools:

• Eask
• Make (optional)

Install all dependencies and development dependencies:

$ eask install-deps --dev

To test the package's installation:

$ eask package
$ eask install

To test compilation:

$ eask compile

🪧 The following steps are optional, but we recommend you follow these lint results!

The built-in checkdoc linter:

$ eask lint checkdoc

The standard package linter:

$ eask lint package

📝 P.S. For more information, find the Eask manual at https://emacs-eask.github.io/.

⚜️ License

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/.

See LICENSE for details.