112 lines
3.1 KiB
Lua
112 lines
3.1 KiB
Lua
local M = {}
|
|
|
|
-- Helper function to find the executable in path, prioritizing non-mason paths
|
|
function M.find_executable(executable)
|
|
-- First try with PATH environment variable
|
|
local paths = vim.split(vim.env.PATH, ':', { plain = true })
|
|
for _, dir in ipairs(paths) do
|
|
if dir ~= '' and not string.find(dir, 'mason') then
|
|
local path = dir .. '/' .. executable
|
|
if vim.fn.filereadable(path) == 1 and vim.fn.executable(path) == 1 then
|
|
return path
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Fallback to mason path if needed
|
|
local path = vim.fn.exepath(executable)
|
|
return path ~= '' and path or nil
|
|
end
|
|
|
|
-- Function to detect python venv path
|
|
function M.get_python_venv_path()
|
|
-- Get the directory of the current file
|
|
local current_file = vim.api.nvim_buf_get_name(0)
|
|
local current_dir = vim.fn.fnamemodify(current_file, ':h')
|
|
|
|
-- Function to find git root
|
|
local function find_git_root(path)
|
|
local git_dir = vim.fn.finddir('.git', path .. ';')
|
|
if git_dir ~= '' then
|
|
return vim.fn.fnamemodify(git_dir, ':h')
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Search paths in order: current directory, git root, user path
|
|
local search_paths = {
|
|
current_dir,
|
|
find_git_root(current_dir),
|
|
vim.fn.expand '~',
|
|
}
|
|
|
|
-- Check each search path for .venv
|
|
for _, path in ipairs(search_paths) do
|
|
if path then
|
|
local venv_path = path .. '/.venv'
|
|
if vim.fn.isdirectory(venv_path) == 1 then
|
|
return venv_path .. '/bin'
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Check for VIRTUAL_ENV environment variable (set by direnv or manually)
|
|
local virtual_env = vim.env.VIRTUAL_ENV
|
|
if virtual_env and virtual_env ~= '' then
|
|
return virtual_env .. '/bin'
|
|
end
|
|
|
|
-- Default to system path
|
|
return nil
|
|
end
|
|
|
|
-- Helper function to find executable in both venv and system PATH
|
|
function M.find_tool(tool_name)
|
|
-- First check virtual env path
|
|
local venv_path = M.get_python_venv_path()
|
|
if venv_path then
|
|
local tool_path = venv_path .. '/' .. tool_name
|
|
if vim.fn.filereadable(tool_path) == 1 then
|
|
return tool_path
|
|
end
|
|
end
|
|
|
|
-- Fall back to executable in PATH
|
|
return M.find_executable(tool_name)
|
|
end
|
|
|
|
-- Get LSP capabilities with cmp support
|
|
function M.get_lsp_capabilities()
|
|
local capabilities = vim.lsp.protocol.make_client_capabilities()
|
|
local ok, cmp_nvim_lsp = pcall(require, 'cmp_nvim_lsp')
|
|
if ok then
|
|
capabilities = vim.tbl_deep_extend('force', capabilities, cmp_nvim_lsp.default_capabilities())
|
|
end
|
|
return capabilities
|
|
end
|
|
|
|
-- Get LSP root directory for current buffer
|
|
function M.get_lsp_root()
|
|
local buf = vim.api.nvim_get_current_buf()
|
|
local clients = vim.lsp.get_clients { bufnr = buf }
|
|
|
|
for _, client in ipairs(clients) do
|
|
if client.config.root_dir then
|
|
return client.config.root_dir
|
|
end
|
|
end
|
|
|
|
-- Fallback to git root or current working directory
|
|
local current_file = vim.api.nvim_buf_get_name(buf)
|
|
local current_dir = vim.fn.fnamemodify(current_file, ':h')
|
|
|
|
local git_root = vim.fs.dirname(vim.fs.find({ '.git' }, { path = current_dir, upward = true })[1])
|
|
if git_root then
|
|
return git_root
|
|
end
|
|
|
|
return vim.fn.getcwd()
|
|
end
|
|
|
|
return M
|