feat: rework path source

Author: Saghen

lua/blink/cmp/sources/path.lua

@@ -0,0 +1,58 @@
+local async = require('blink.cmp.sources.lib.async')
+local uv = vim.uv
+local fs = {}
+
+--- Scans a directory asynchronously in a loop until
+--- it finds all entries
+--- @param path string
+--- @return blink.cmp.Task
+function fs.scan_dir_async(path)
+  local max_entries = 200
+  return async.task.new(function(resolve, reject)
+    uv.fs_opendir(path, function(err, handle)
+      if err ~= nil or handle == nil then return reject(err) end
+
+      local all_entries = {}
+
+      local function read_dir()
+        uv.fs_readdir(handle, function(err, entries)
+          if err ~= nil or entries == nil then return reject(err) end
+
+          vim.list_extend(all_entries, entries)
+          if #entries == max_entries then
+            read_dir()
+          else
+            resolve(all_entries)
+          end
+        end)
+      end
+      read_dir()
+    end, max_entries)
+  end)
+end
+
+--- @param entries { name: string, type: string }[]
+--- @return blink.cmp.Task
+function fs.fs_stat_all(cwd, entries)
+  local tasks = {}
+  for _, entry in ipairs(entries) do
+    table.insert(
+      tasks,
+      async.task.new(function(resolve, reject)
+        uv.fs_stat(cwd .. '/' .. entry.name, function(err, stat)
+          if err then return reject(err) end
+          resolve({ name = entry.name, type = entry.type, stat = stat })
+        end)
+      end)
+    )
+  end
+  return async.task.await_all(tasks):map(function(tasks_results)
+    local resolved_entries = {}
+    for _, entry in ipairs(tasks_results) do
+      if entry.status == async.STATUS.COMPLETED then table.insert(resolved_entries, entry.result) end
+    end
+    return resolved_entries
+  end)
+end
+
+return fs

lua/blink/cmp/sources/path/fs.lua

@@ -0,0 +1,49 @@
+-- credit to https://github.com/hrsh7th/cmp-path for the original implementation
+-- and https://codeberg.org/FelipeLema/cmp-async-path for the async implementation
+
+local path = {}
+local NAME_REGEX = '\\%([^/\\\\:\\*?<>\'"`\\|]\\)'
+local PATH_REGEX =
+  assert(vim.regex(([[\%(\%(/PAT*[^/\\\\:\\*?<>\'"`\\| .~]\)\|\%(/\.\.\)\)*/\zePAT*$]]):gsub('PAT', NAME_REGEX)))
+
+function path.new(opts)
+  local self = setmetatable({}, { __index = path })
+
+  opts = vim.tbl_deep_extend('keep', 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 = false,
+  })
+  vim.validate({
+    trailing_slash = { opts.trailing_slash, 'boolean' },
+    label_trailing_slash = { opts.label_trailing_slash, 'boolean' },
+    get_cwd = { opts.get_cwd, 'function' },
+    show_hidden_files_by_default = { opts.show_hidden_files_by_default, 'boolean' },
+  })
+
+  self.opts = opts or {}
+  return self
+end
+
+function path:get_trigger_characters() return { '/', '.' } end
+
+function path:get_completions(context, callback)
+  local lib = require('blink.cmp.sources.path.lib')
+
+  local dirname = lib.dirname(PATH_REGEX, self.opts.get_cwd, context)
+  if not dirname then return callback() end
+
+  local include_hidden = self.opts.show_hidden_files_by_default
+    or string.sub(context.line, context.bounds.start_col - 1, context.bounds.start_col - 1) == '.'
+  lib
+    .candidates(dirname, include_hidden, self.opts)
+    :map(
+      function(candidates)
+        callback({ is_incomplete_forward = false, is_incomplete_backward = true, items = candidates })
+      end
+    )
+    :catch(function() callback() end)
+end
+
+return path

lua/blink/cmp/sources/path/init.lua

@@ -0,0 +1,81 @@
+local lib = {}
+
+--- @param path_regex vim.regex
+--- @param get_cwd fun(context: blink.cmp.CompletionContext): string
+--- @param context blink.cmp.CompletionContext
+function lib.dirname(path_regex, get_cwd, context)
+  local line_before_cursor = context.line:sub(1, context.cursor[2])
+  local s = path_regex:match_str(line_before_cursor)
+  if not s then return nil end
+
+  local dirname = string.gsub(string.sub(line_before_cursor, s + 2), '%a*$', '') -- exclude '/'
+  local prefix = string.sub(line_before_cursor, 1, s + 1) -- include '/'
+
+  local buf_dirname = get_cwd(context)
+  if vim.api.nvim_get_mode().mode == 'c' then buf_dirname = vim.fn.getcwd() end
+  if prefix:match('%.%./$') then return vim.fn.resolve(buf_dirname .. '/../' .. dirname) end
+  if prefix:match('%./$') or prefix:match('"$') or prefix:match("'$") then
+    return vim.fn.resolve(buf_dirname .. '/' .. dirname)
+  end
+  if prefix:match('~/$') then return vim.fn.resolve(vim.fn.expand('~') .. '/' .. dirname) end
+  local env_var_name = prefix:match('%$([%a_]+)/$')
+  if env_var_name then
+    local env_var_value = vim.fn.getenv(env_var_name)
+    if env_var_value ~= vim.NIL then return vim.fn.resolve(env_var_value .. '/' .. dirname) end
+  end
+  if prefix:match('/$') then
+    local accept = true
+    -- Ignore URL components
+    accept = accept and not prefix:match('%a/$')
+    -- Ignore URL scheme
+    accept = accept and not prefix:match('%a+:/$') and not prefix:match('%a+://$')
+    -- Ignore HTML closing tags
+    accept = accept and not prefix:match('</$')
+    -- Ignore math calculation
+    accept = accept and not prefix:match('[%d%)]%s*/$')
+    -- Ignore / comment
+    accept = accept and (not prefix:match('^[%s/]*$') or not self:_is_slash_comment())
+    if accept then return vim.fn.resolve('/' .. dirname) end
+  end
+  return nil
+end
+
+--- @param dirname string
+--- @param include_hidden boolean
+--- @param opts table
+function lib.candidates(dirname, include_hidden, opts)
+  local fs = require('blink.cmp.sources.path.fs')
+  return fs.scan_dir_async(dirname)
+    :map(function(entries) return fs.fs_stat_all(dirname, entries) end)
+    :map(function(entries)
+      return vim.tbl_filter(function(entry) return include_hidden or entry.name ~= '.' end, entries)
+    end)
+    :map(function(entries)
+      return vim.tbl_map(function(entry) return lib.entry_to_completion_item(entry, opts) end, entries)
+    end)
+end
+
+function lib.is_slash_comment(_)
+  local commentstring = vim.bo.commentstring or ''
+  local no_filetype = vim.bo.filetype == ''
+  local is_slash_comment = false
+  is_slash_comment = is_slash_comment or commentstring:match('/%*')
+  is_slash_comment = is_slash_comment or commentstring:match('//')
+  return is_slash_comment and not no_filetype
+end
+
+--- @param entry { name: string, type: string, stat: table }
+--- @param opts table
+--- @return blink.cmp.CompletionItem[]
+function lib.entry_to_completion_item(entry, opts)
+  local is_dir = entry.type == 'directory'
+  return {
+    label = (opts.label_trailing_slash and is_dir) and entry.name .. '/' or entry.name,
+    kind = is_dir and vim.lsp.protocol.CompletionItemKind.Folder or vim.lsp.protocol.CompletionItemKind.File,
+    insertText = is_dir and entry.name .. '/' or entry.name,
+    word = opts.trailing_slash and entry.name or nil,
+    data = { path = entry.name, type = entry.type, stat = entry.stat },
+  }
+end
+
+return lib