feat!: rework sources system and configuration

Closes #144

Author: Saghen

lua/blink/cmp/config.lua

@@ -50,17 +50,22 @@
 --- @field signature_help? blink.cmp.SignatureHelpTriggerConfig
 
 --- @class blink.cmp.SourceConfig
---- @field providers? blink.cmp.SourceProviderConfig[]
+--- @field completion? string[] | fun(ctx?: blink.cmp.Context): string[]
+--- @field providers? table<string, blink.cmp.SourceProviderConfig>
 ---
 --- @class blink.cmp.SourceProviderConfig
---- @field [1]? string
 --- @field name string
---- @field fallback_for? string[] | nil
---- @field keyword_length? number | nil
---- @field score_offset? number | nil
---- @field deduplicate? blink.cmp.DeduplicateConfig | nil
---- @field trigger_characters? string[] | nil
---- @field opts? table | nil
+--- @field module string
+--- @field enabled? boolean | fun(ctx?: blink.cmp.Context): boolean
+--- @field opts? table
+--- @field transform_items? fun(ctx: blink.cmp.Context, items: blink.cmp.CompletionItem[]): blink.cmp.CompletionItem[]
+--- @field should_show_items? boolean | number | fun(ctx: blink.cmp.Context, items: blink.cmp.CompletionItem[]): boolean
+--- @field max_items? number | fun(ctx: blink.cmp.Context, enabled_sources: string[], items: blink.cmp.CompletionItem[]): number
+--- @field min_keyword_length? number | fun(ctx: blink.cmp.Context, enabled_sources: string[]): number
+--- @field fallback_for? string[] | fun(ctx: blink.cmp.Context, enabled_sources: string[]): string[]
+--- @field score_offset? number | fun(ctx: blink.cmp.Context, enabled_sources: string[]): number
+--- @field deduplicate? blink.cmp.DeduplicateConfig
+--- @field override? blink.cmp.SourceOverride
 ---
 --- @class blink.cmp.DeduplicateConfig
 --- @field enabled? boolean
@@ -244,15 +249,30 @@ local config = {
   },
 
   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
+    -- list of enabled providers
+    completion = { 'lsp', 'path', 'snippets', 'buffer' },
+
+    -- table of providers to configure
     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' } },
+      lsp = {
+        name = 'LSP',
+        module = 'blink.cmp.sources.lsp',
+      },
+      path = {
+        name = 'Path',
+        module = 'blink.cmp.sources.path',
+        score_offset = 3,
+      },
+      snippets = {
+        name = 'Snippets',
+        module = 'blink.cmp.sources.snippets',
+        score_offset = -3,
+      },
+      buffer = {
+        name = 'Buffer',
+        module = 'blink.cmp.sources.buffer',
+        fallback_for = { 'lsp' },
+      },
     },
   },
 

lua/blink/cmp/fuzzy/frecency.rs

@@ -10,15 +10,15 @@ use std::time::{SystemTime, UNIX_EPOCH};
 struct CompletionItemKey {
     label: String,
     kind: u32,
-    source: String,
+    source_id: String,
 }
 
 impl From<&LspItem> for CompletionItemKey {
     fn from(item: &LspItem) -> Self {
         Self {
             label: item.label.clone(),
             kind: item.kind,
-            source: item.source.clone(),
+            source_id: item.source_id.clone(),
         }
     }
 }

lua/blink/cmp/fuzzy/fuzzy.rs

@@ -17,7 +17,7 @@ pub struct LspItem {
     pub filter_text: Option<String>,
     pub kind: u32,
     pub score_offset: Option<i32>,
-    pub source: String,
+    pub source_id: String,
 }
 
 impl FromLua<'_> for LspItem {
@@ -28,15 +28,15 @@ impl FromLua<'_> for LspItem {
             let filter_text: Option<String> = tab.get("filterText").ok();
             let kind: u32 = tab.get("kind").unwrap_or_default();
             let score_offset: Option<i32> = tab.get("score_offset").ok();
-            let source: String = tab.get("source").unwrap_or_default();
+            let source_id: String = tab.get("source_id").unwrap_or_default();
 
             Ok(LspItem {
                 label,
                 sort_text,
                 filter_text,
                 kind,
                 score_offset,
-                source,
+                source_id,
             })
         } else {
             Err(mlua::Error::FromLuaConversionError {

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

@@ -1,10 +1,23 @@
 local utils = require('blink.cmp.sources.lib.utils')
 local async = require('blink.cmp.sources.lib.async')
+
+--- @class blink.cmp.SourcesContext
+--- @field id number
+--- @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 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 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
+--- @field destroy fun(self: blink.cmp.SourcesContext)
+
+--- @type blink.cmp.SourcesContext
+--- @diagnostic disable-next-line: missing-fields
 local sources_context = {}
 
---- @param context blink.cmp.Context
---- @param sources blink.cmp.SourceProvider[]
---- @param on_completions_callback fun(context: blink.cmp.Context, items: blink.cmp.CompletionItem[])
 function sources_context.new(context, sources, on_completions_callback)
   local self = setmetatable({}, { __index = sources_context })
   self.id = context.id
@@ -18,7 +31,6 @@ function sources_context.new(context, sources, on_completions_callback)
   return self
 end
 
---- @param context blink.cmp.Context
 function sources_context:get_completions(context)
   assert(context.id == self.id, 'Requested completions on a sources context with a different context ID')
 
@@ -43,13 +55,14 @@ function sources_context:get_completions(context)
   end)
 end
 
---- @param sources blink.cmp.SourceProvider[]
---- @param context blink.cmp.Context
---- @return blink.cmp.Task
 function sources_context:get_completions_for_sources(sources, context)
+  local enabled_sources = vim.tbl_keys(sources)
+  --- @type blink.cmp.SourceProvider[]
   local non_fallback_sources = vim.tbl_filter(
-    function(source) return source.config.fallback_for == nil or #source.config.fallback_for == 0 end,
-    sources
+    function(source)
+      return source.config.fallback_for == nil or #source.config.fallback_for(context, enabled_sources) == 0
+    end,
+    vim.tbl_values(sources)
   )
 
   -- get completions for each non-fallback source
@@ -73,16 +86,19 @@ function sources_context:get_completions_for_sources(sources, context)
     :map(function(tasks_results)
       local is_cached = true
       local items = {}
-      -- for each task, filter the items and add them to the list
-      -- if the source should show the completions
+      -- for each task, add them to the list if the source should show the items
       for idx, task_result in ipairs(tasks_results) do
         if task_result.status == async.STATUS.COMPLETED then
-          is_cached = is_cached and (task_result.result.is_cached or false)
-          local source = sources[idx]
+          --- @type blink.cmp.SourceProvider
+          local source = vim.tbl_values(sources)[idx]
           --- @type blink.cmp.CompletionResponse
           local response = task_result.result
-          response.items = source:filter_completions(response)
-          if source:should_show_completions(context, response) then vim.list_extend(items, response.items) end
+
+          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
         end
       end
       return { is_cached = is_cached, items = items }
@@ -95,22 +111,19 @@ end
 
 --- Runs the source's get_completions function, falling back to other sources
 --- with fallback_for = { source.name } if the source returns no completion items
---- @param context blink.cmp.Context
---- @param source blink.cmp.SourceProvider
---- @param sources blink.cmp.SourceProvider[]
---- @return blink.cmp.Task
 --- TODO: When a source has multiple fallbacks, we may end up with duplicate completion items
 function sources_context:get_completions_with_fallbacks(context, source, sources)
+  local enabled_sources = vim.tbl_keys(sources)
   local fallback_sources = vim.tbl_filter(
     function(fallback_source)
-      return fallback_source.name ~= source.name
+      return fallback_source.id ~= source.id
         and fallback_source.config.fallback_for ~= nil
-        and vim.tbl_contains(fallback_source.config.fallback_for, source.name)
+        and vim.tbl_contains(fallback_source.config.fallback_for(context), source.id)
     end,
-    sources
+    vim.tbl_values(sources)
   )
 
-  return source:get_completions(context):map(function(response)
+  return source:get_completions(context, enabled_sources):map(function(response)
     -- source returned completions, no need to fallback
     if #response.items > 0 or #fallback_sources == 0 then return response end
 

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

@@ -1,5 +1,27 @@
 local async = require('blink.cmp.sources.lib.async')
 local config = require('blink.cmp.config')
+
+--- @class blink.cmp.Sources
+--- @field current_context blink.cmp.SourcesContext | nil
+--- @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 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 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
+--- @field cancel_signature_help fun()
+--- @field reload fun()
+
+--- @type blink.cmp.Sources
+--- @diagnostic disable-next-line: missing-fields
 local sources = {
   current_context = nil,
   sources_registered = false,
@@ -8,24 +30,38 @@ local sources = {
 }
 
 function sources.register()
-  assert(#sources.providers == 0, 'Sources have already been registered')
+  assert(not sources.sources_registered, 'Sources have already been registered')
+  sources.sources_registered = true
+
+  for key, source_config in pairs(config.sources.providers) do
+    sources.providers[key] = require('blink.cmp.sources.lib.provider').new(key, source_config)
+  end
+end
+
+function sources.get_enabled_providers(context)
+  local mode_providers = type(config.sources.completion) == 'function' and config.sources.completion(context)
+    or config.sources.completion
+  --- @cast mode_providers string[]
 
-  for _, source_config in ipairs(config.sources.providers) do
-    table.insert(sources.providers, require('blink.cmp.sources.lib.provider').new(source_config))
+  --- @type table<string, blink.cmp.SourceProvider>
+  local providers = {}
+  for key, provider in pairs(sources.providers) do
+    if provider.config.enabled(context) and vim.tbl_contains(mode_providers, key) then providers[key] = provider end
   end
+  return providers
 end
 
 --- Completion ---
 
---- @return string[]
 function sources.get_trigger_characters()
+  local providers = sources.get_enabled_providers()
   local blocked_trigger_characters = {}
   for _, char in ipairs(config.trigger.completion.blocked_trigger_characters) do
     blocked_trigger_characters[char] = true
   end
 
   local trigger_characters = {}
-  for _, source in pairs(sources.providers) do
+  for _, source in pairs(providers) do
     local source_trigger_characters = source:get_trigger_characters()
     for _, char in ipairs(source_trigger_characters) do
       if not blocked_trigger_characters[char] then table.insert(trigger_characters, char) end
@@ -36,14 +72,16 @@ end
 
 function sources.listen_on_completions(callback) sources.on_completions_callback = callback end
 
---- @param context blink.cmp.Context
 function sources.request_completions(context)
   -- create a new context if the id changed or if we haven't created one yet
   local is_new_context = sources.current_context == nil or context.id ~= sources.current_context.id
   if is_new_context then
     if sources.current_context ~= nil then sources.current_context:destroy() end
-    sources.current_context =
-      require('blink.cmp.sources.lib.context').new(context, sources.providers, sources.on_completions_callback)
+    sources.current_context = require('blink.cmp.sources.lib.context').new(
+      context,
+      sources.get_enabled_providers(context),
+      sources.on_completions_callback
+    )
   end
 
   sources.current_context:get_completions(context)
@@ -58,13 +96,10 @@ end
 
 --- Resolve ---
 
---- @param item blink.cmp.CompletionItem
---- @param callback fun(resolved_item: blink.cmp.CompletionItem | nil)
---- @return fun(): nil Cancelation function
 function sources.resolve(item, callback)
   local item_source = nil
-  for _, source in ipairs(sources.providers) do
-    if source.name == item.source then
+  for _, source in pairs(sources.providers) do
+    if source.id == item.source_id then
       item_source = source
       break
     end
@@ -82,7 +117,6 @@ end
 
 --- Signature help ---
 
---- @return { trigger_characters: string[], retrigger_characters: string[] }
 function sources.get_signature_help_trigger_characters()
   local blocked_trigger_characters = {}
   local blocked_retrigger_characters = {}
@@ -97,7 +131,7 @@ function sources.get_signature_help_trigger_characters()
   local retrigger_characters = {}
 
   -- todo: should this be all source groups?
-  for _, source in ipairs(sources.providers) do
+  for _, source in pairs(sources.providers) do
     local res = source:get_signature_help_trigger_characters()
     for _, char in ipairs(res.trigger_characters) do
       if not blocked_trigger_characters[char] then table.insert(trigger_characters, char) end
@@ -109,11 +143,9 @@ function sources.get_signature_help_trigger_characters()
   return { trigger_characters = trigger_characters, retrigger_characters = retrigger_characters }
 end
 
---- @param context blink.cmp.SignatureHelpContext
---- @param callback fun(signature_helps: lsp.SignatureHelp)
 function sources.get_signature_help(context, callback)
   local tasks = {}
-  for _, source in ipairs(sources.providers) do
+  for _, source in pairs(sources.providers) do
     table.insert(tasks, source:get_signature_help(context))
   end
   sources.current_signature_help = async.task.await_all(tasks):map(function(tasks_results)