feat!: rework sources config structure and available options

Closes #144

Author: Saghen

README.md

@@ -233,57 +233,47 @@ MiniDeps.add({
   },
 
   sources = {
-    -- similar to nvim-cmp's sources, but we point directly to the source's lua module
-    -- multiple groups can be provided, where it'll fallback to the next group if the previous
-    -- returns no completion items
-    -- WARN: This API will have breaking changes during the beta
-    providers = {
-      { 'blink.cmp.sources.lsp', name = 'LSP' },
-      { 'blink.cmp.sources.path', name = 'Path', score_offset = 3 },
-      { 'blink.cmp.sources.snippets', name = 'Snippets', score_offset = -3 },
-      { 'blink.cmp.sources.buffer', name = 'Buffer', fallback_for = { 'LSP' } },
-    },
-    -- WARN: **For reference only** to see what options are available. **See above for the default config**
+    -- list of enabled providers
+    completion = { 
+      enabled_providers = {'lsp', 'path', 'snippets', 'buffer' },
+    }
+
     providers = {
-      -- all of these properties work on every source
-      {
-          'blink.cmp.sources.lsp',
-          name = 'LSP',
-          keyword_length = 0,
-          score_offset = 0,
-          trigger_characters = { 'f', 'o', 'o' },
+      lsp = {
+        name = 'LSP',
+        module = 'blink.cmp.sources.lsp',
+
+        --- *All* of the providers have the following options available
+        --- NOTE: All of these options may be functions to enable dynamic behavior
+        --- See the type definitions for more information
+        enabled = true, -- whether or not to enable the provider
+        transform_items = nil, -- function to transform the items before they're returned
+        should_show_items = true, -- whether or not to show the items
+        max_items = nil, -- maximum number of items to return
+        min_keyword_length = 0, -- minimum number of characters to trigger the provider
+        fallback_for = {}, -- if any of these providers return 0 items, it will fallback to this provider
+        score_offset = 0, -- boost/penalize the score of the items
+        override = nil, -- override the source's functions
       },
-      -- the following two sources have additional options
-      {
-        'blink.cmp.sources.path',
+      path = {
         name = 'Path',
+        module = 'blink.cmp.sources.path',
         score_offset = 3,
-        opts = {
-          trailing_slash = false,
-          label_trailing_slash = true,
-          get_cwd = function(context) return vim.fn.expand(('#%d:p:h'):format(context.bufnr)) end,
-          show_hidden_files_by_default = true,
-        }
       },
-      {
-        'blink.cmp.sources.snippets',
+      snippets = {
         name = 'Snippets',
+        module = 'blink.cmp.sources.snippets',
         score_offset = -3,
-        -- similar to https://github.com/garymjr/nvim-snippets
-        opts = {
-          friendly_snippets = true,
-          search_paths = { vim.fn.stdpath('config') .. '/snippets' },
-          global_snippets = { 'all' },
-          extended_filetypes = {},
-          ignored_filetypes = {},
-        },
+
+        --- Example usage for disabling the snippet provider after pressing trigger characters (i.e. ".")
+        -- enabled = function(ctx) return ctx ~= nil and ctx.trigger.kind == vim.lsp.protocol.CompletionTriggerKind.TriggerCharacter end,
       },
-      {
-        'blink.cmp.sources.buffer',
+      buffer = {
         name = 'Buffer',
-        fallback_for = { 'LSP' },
-      }
-    }
+        module = 'blink.cmp.sources.buffer',
+        fallback_for = { 'lsp' },
+      },
+    },
   },
 
   windows = {
@@ -437,7 +427,6 @@ The plugin use a 4 stage pipeline: trigger -> sources -> fuzzy -> render
 
 ### Planned missing features
 
-- Less customizable with regards to trigger, sources, sorting, filtering
 - Significantly less testing and documentation
 - Ghost text
 - Matched character highlighting

lua/blink/cmp/config.lua

@@ -50,9 +50,12 @@
 --- @field signature_help? blink.cmp.SignatureHelpTriggerConfig
 
 --- @class blink.cmp.SourceConfig
---- @field completion? string[] | fun(ctx?: blink.cmp.Context): string[]
+--- @field completion? blink.cmp.SourceModeConfig
 --- @field providers? table<string, blink.cmp.SourceProviderConfig>
 ---
+--- @class blink.cmp.SourceModeConfig
+--- @field enabled_providers? string[] | fun(ctx?: blink.cmp.Context): string[]
+---
 --- @class blink.cmp.SourceProviderConfig
 --- @field name string
 --- @field module string
@@ -250,7 +253,9 @@ local config = {
 
   sources = {
     -- list of enabled providers
-    completion = { 'lsp', 'path', 'snippets', 'buffer' },
+    completion = {
+      enabled_providers = { 'lsp', 'path', 'snippets', 'buffer' },
+    },
 
     -- table of providers to configure
     providers = {

lua/blink/cmp/fuzzy/init.lua

@@ -1,10 +1,6 @@
 local config = require('blink.cmp.config')
 
 local fuzzy = {
-  ---@type blink.cmp.Context?
-  last_context = nil,
-  ---@type blink.cmp.CompletionItem[]?
-  last_items = nil,
   rust = require('blink.cmp.fuzzy.rust'),
 }
 
@@ -63,20 +59,6 @@ function fuzzy.filter_items(needle, haystack)
   return filtered_items
 end
 
----@param needle string
----@param context blink.cmp.Context
----@param items blink.cmp.CompletionItem[]?
-function fuzzy.filter_items_with_cache(needle, context, items)
-  if items == nil then
-    if fuzzy.last_context == nil or fuzzy.last_context.id ~= context.id then return {} end
-    items = fuzzy.last_items
-  end
-  fuzzy.last_context = context
-  fuzzy.last_items = items
-
-  return fuzzy.filter_items(needle, items)
-end
-
 --- Gets the text under the cursor to be used for fuzzy matching
 --- @return string
 function fuzzy.get_query()

lua/blink/cmp/init.lua

@@ -32,36 +32,31 @@ cmp.setup = function(opts)
       documentation = require('blink.cmp.windows.documentation').setup(),
     }
 
-    -- fuzzy combines smith waterman with frecency
-    -- and bonus from proximity words but I'm still working
-    -- on tuning the weights
-    --- @param context blink.cmp.Context
-    --- @param items blink.cmp.CompletionItem[] | nil
-    local function update_completions(context, items)
+    cmp.trigger.listen_on_show(function(context) cmp.sources.request_completions(context) end)
+    cmp.trigger.listen_on_hide(function()
+      cmp.sources.cancel_completions()
+      cmp.windows.autocomplete.close()
+    end)
+    cmp.sources.listen_on_completions(function(context, items)
+      -- fuzzy combines smith waterman with frecency
+      -- and bonus from proximity words but I'm still working
+      -- on tuning the weights
       if not cmp.fuzzy then
         cmp.fuzzy = require('blink.cmp.fuzzy')
         cmp.fuzzy.init_db(vim.fn.stdpath('data') .. '/blink/cmp/fuzzy.db')
       end
-      -- we avoid adding 1-4ms to insertion latency by scheduling for later
+
+      -- we avoid adding 0.5-4ms to insertion latency by scheduling for later
       vim.schedule(function()
-        local filtered_items = cmp.fuzzy.filter_items_with_cache(cmp.fuzzy.get_query(), context, items)
+        local filtered_items = cmp.fuzzy.filter_items(cmp.fuzzy.get_query(), items)
+        filtered_items = cmp.sources.apply_max_items_for_completions(context, filtered_items)
         if #filtered_items > 0 then
           cmp.windows.autocomplete.open_with_items(context, filtered_items)
         else
           cmp.windows.autocomplete.close()
         end
       end)
-    end
-
-    cmp.trigger.listen_on_show(function(context)
-      update_completions(context) -- immediately update via cache on keystroke
-      cmp.sources.request_completions(context)
-    end)
-    cmp.trigger.listen_on_hide(function()
-      cmp.sources.cancel_completions()
-      cmp.windows.autocomplete.close()
     end)
-    cmp.sources.listen_on_completions(update_completions)
 
     -- setup signature help if enabled
     if config.trigger.signature_help.enabled then cmp.setup_signature_help() end

lua/blink/cmp/sources/lib/context.lua

@@ -6,9 +6,12 @@ local async = require('blink.cmp.sources.lib.async')
 --- @field sources table<string, blink.cmp.SourceProvider>
 --- @field active_request blink.cmp.Task | nil
 --- @field queued_request_context blink.cmp.Context | nil
---- @field on_completions_callback fun(context: blink.cmp.Context, items: blink.cmp.CompletionItem[])
+--- @field cached_responses table<string, blink.cmp.CompletionResponse> | nil
+--- @field on_completions_callback fun(context: blink.cmp.Context, enabled_sources: string[], responses: table<string, blink.cmp.CompletionResponse>)
 ---
---- @field new fun(context: blink.cmp.Context, sources: table<string, blink.cmp.SourceProvider>, on_completions_callback: fun(context: blink.cmp.Context, items: blink.cmp.CompletionItem[])): blink.cmp.SourcesContext
+--- @field new fun(context: blink.cmp.Context, sources: table<string, blink.cmp.SourceProvider>, on_completions_callback: fun(context: blink.cmp.Context, items: table<string, blink.cmp.CompletionResponse>)): blink.cmp.SourcesContext
+--- @field get_sources fun(self: blink.cmp.SourcesContext): string[]
+--- @field get_cached_completions fun(self: blink.cmp.SourcesContext): table<string, blink.cmp.CompletionResponse> | nil
 --- @field get_completions fun(self: blink.cmp.SourcesContext, context: blink.cmp.Context)
 --- @field get_completions_for_sources fun(self: blink.cmp.SourcesContext, sources: table<string, blink.cmp.SourceProvider>, context: blink.cmp.Context): blink.cmp.Task
 --- @field get_completions_with_fallbacks fun(self: blink.cmp.SourcesContext, context: blink.cmp.Context, source: blink.cmp.SourceProvider, sources: table<string, blink.cmp.SourceProvider>): blink.cmp.Task
@@ -25,12 +28,15 @@ function sources_context.new(context, sources, on_completions_callback)
 
   self.active_request = nil
   self.queued_request_context = nil
-  --- @type fun(context: blink.cmp.Context, items: blink.cmp.CompletionItem[])
   self.on_completions_callback = on_completions_callback
 
   return self
 end
 
+function sources_context:get_sources() return vim.tbl_keys(self.sources) end
+
+function sources_context:get_cached_completions() return self.cached_responses end
+
 function sources_context:get_completions(context)
   assert(context.id == self.id, 'Requested completions on a sources context with a different context ID')
 
@@ -41,10 +47,17 @@ function sources_context:get_completions(context)
 
   -- Create a task to get the completions, send responses upstream
   -- and run the queued request, if it exists
-  self.active_request = self:get_completions_for_sources(self.sources, context):map(function(response)
+  self.active_request = self:get_completions_for_sources(self.sources, context):map(function(responses)
+    self.cached_responses = responses
+    --- @cast responses table<string, blink.cmp.CompletionResponse>
     self.active_request = nil
-    -- only send upstream if the response contains something new
-    if not response.is_cached then self.on_completions_callback(context, response.items) end
+
+    -- only send upstream if the responses contain something new
+    local is_cached = true
+    for _, response in pairs(responses) do
+      is_cached = is_cached and (response.is_cached or false)
+    end
+    if not is_cached then self.on_completions_callback(context, self:get_sources(), responses) end
 
     -- run the queued request, if it exists
     if self.queued_request_context ~= nil then
@@ -84,28 +97,19 @@ function sources_context:get_completions_for_sources(sources, context)
   return async.task
     .await_all(tasks)
     :map(function(tasks_results)
-      local is_cached = true
-      local items = {}
-      -- for each task, add them to the list if the source should show the items
+      local responses = {}
       for idx, task_result in ipairs(tasks_results) do
         if task_result.status == async.STATUS.COMPLETED then
           --- @type blink.cmp.SourceProvider
-          local source = vim.tbl_values(sources)[idx]
-          --- @type blink.cmp.CompletionResponse
-          local response = task_result.result
-
-          is_cached = is_cached and (response.is_cached or false)
-
-          if source:should_show_items(context, enabled_sources, response) then
-            vim.list_extend(items, response.items)
-          end
+          local source = vim.tbl_values(non_fallback_sources)[idx]
+          responses[source.id] = task_result.result
         end
       end
-      return { is_cached = is_cached, items = items }
+      return responses
     end)
     :catch(function(err)
       vim.print('failed to get completions for sources with error: ' .. err)
-      return { is_cached = false, items = {} }
+      return {}
     end)
 end
 

lua/blink/cmp/sources/lib/init.lua

@@ -6,14 +6,15 @@ local config = require('blink.cmp.config')
 --- @field current_signature_help blink.cmp.Task | nil
 --- @field sources_registered boolean
 --- @field providers table<string, blink.cmp.SourceProvider>
---- @field on_completions_callback fun(context: blink.cmp.Context, items: blink.cmp.CompletionItem[])
+--- @field on_completions_callback fun(context: blink.cmp.Context, enabled_sources: table<string, blink.cmp.SourceProvider>, responses: table<string, blink.cmp.CompletionResponse>)
 ---
 --- @field register fun()
 --- @field get_enabled_providers fun(context?: blink.cmp.Context): table<string, blink.cmp.SourceProvider>
 --- @field get_trigger_characters fun(): string[]
 --- @field request_completions fun(context: blink.cmp.Context)
 --- @field cancel_completions fun()
 --- @field listen_on_completions fun(callback: fun(context: blink.cmp.Context, items: blink.cmp.CompletionItem[]))
+--- @field apply_max_items_for_completions fun(context: blink.cmp.Context, items: blink.cmp.CompletionItem[]): blink.cmp.CompletionItem[]
 --- @field resolve fun(item: blink.cmp.CompletionItem, callback: fun(resolved_item: lsp.CompletionItem | nil)): (fun(): nil) | nil
 --- @field get_signature_help_trigger_characters fun(): { trigger_characters: string[], retrigger_characters: string[] }
 --- @field get_signature_help fun(context: blink.cmp.SignatureHelpContext, callback: fun(signature_help: lsp.SignatureHelp | nil)): (fun(): nil) | nil
@@ -39,8 +40,9 @@ function sources.register()
 end
 
 function sources.get_enabled_providers(context)
-  local mode_providers = type(config.sources.completion) == 'function' and config.sources.completion(context)
-    or config.sources.completion
+  local mode_providers = type(config.sources.completion.enabled_providers) == 'function'
+      and config.sources.completion.enabled_providers(context)
+    or config.sources.completion.enabled_providers
   --- @cast mode_providers string[]
 
   --- @type table<string, blink.cmp.SourceProvider>
@@ -70,7 +72,17 @@ function sources.get_trigger_characters()
   return trigger_characters
 end
 
-function sources.listen_on_completions(callback) sources.on_completions_callback = callback end
+function sources.listen_on_completions(callback)
+  sources.on_completions_callback = function(context, enabled_sources, responses)
+    local items = {}
+    for id, response in pairs(responses) do
+      if sources.providers[id]:should_show_items(context, enabled_sources, response.items) then
+        vim.list_extend(items, response.items)
+      end
+    end
+    callback(context, items)
+  end
+end
 
 function sources.request_completions(context)
   -- create a new context if the id changed or if we haven't created one yet
@@ -82,6 +94,13 @@ function sources.request_completions(context)
       sources.get_enabled_providers(context),
       sources.on_completions_callback
     )
+  -- send cached completions if they exist to immediately trigger updates
+  elseif sources.current_context:get_cached_completions() ~= nil then
+    sources.on_completions_callback(
+      context,
+      sources.current_context:get_sources(),
+      sources.current_context:get_cached_completions()
+    )
   end
 
   sources.current_context:get_completions(context)
@@ -94,6 +113,33 @@ function sources.cancel_completions()
   end
 end
 
+--- Limits the number of items per source as configured
+function sources.apply_max_items_for_completions(context, items)
+  local enabled_sources = sources.get_enabled_providers(context)
+
+  -- get the configured max items for each source
+  local total_items_for_sources = {}
+  local max_items_for_sources = {}
+  for id, source in pairs(sources.providers) do
+    max_items_for_sources[id] = source.config.max_items(context, enabled_sources, items)
+    total_items_for_sources[id] = 0
+  end
+
+  -- no max items configured, return as-is
+  if #vim.tbl_keys(max_items_for_sources) == 0 then return items end
+
+  -- apply max items
+  local filtered_items = {}
+  for _, item in ipairs(items) do
+    local max_items = max_items_for_sources[item.source_id]
+    total_items_for_sources[item.source_id] = total_items_for_sources[item.source_id] + 1
+    if max_items == nil or total_items_for_sources[item.source_id] <= max_items then
+      table.insert(filtered_items, item)
+    end
+  end
+  return filtered_items
+end
+
 --- Resolve ---
 
 function sources.resolve(item, callback)

lua/blink/cmp/sources/lib/provider/init.lua

@@ -87,7 +87,7 @@ end
 function source:should_show_items(context, enabled_sources, response)
   -- if keyword length is configured, check if the context is long enough
   local min_keyword_length = self.config.min_keyword_length(context, enabled_sources)
-  local current_keyword_length = context.bounds.end_col - context.bounds.start_col
+  local current_keyword_length = context.bounds.length
   if current_keyword_length < min_keyword_length then return false end
 
   if self.config.should_show_items == nil then return true end