mirror of
https://github.com/neovim/neovim.git
synced 2024-12-22 12:15:06 -07:00
600 lines
20 KiB
Lua
600 lines
20 KiB
Lua
local protocol = require 'vim.lsp.protocol'
|
|
local validate = vim.validate
|
|
local api = vim.api
|
|
|
|
local M = {}
|
|
|
|
local split = vim.split
|
|
local function split_lines(value)
|
|
return split(value, '\n', true)
|
|
end
|
|
|
|
local list_extend = vim.list_extend
|
|
|
|
--- Find the longest shared prefix between prefix and word.
|
|
-- e.g. remove_prefix("123tes", "testing") == "ting"
|
|
local function remove_prefix(prefix, word)
|
|
local max_prefix_length = math.min(#prefix, #word)
|
|
local prefix_length = 0
|
|
for i = 1, max_prefix_length do
|
|
local current_line_suffix = prefix:sub(-i)
|
|
local word_prefix = word:sub(1, i)
|
|
if current_line_suffix == word_prefix then
|
|
prefix_length = i
|
|
end
|
|
end
|
|
return word:sub(prefix_length + 1)
|
|
end
|
|
|
|
local function resolve_bufnr(bufnr)
|
|
if bufnr == nil or bufnr == 0 then
|
|
return api.nvim_get_current_buf()
|
|
end
|
|
return bufnr
|
|
end
|
|
|
|
-- local valid_windows_path_characters = "[^<>:\"/\\|?*]"
|
|
-- local valid_unix_path_characters = "[^/]"
|
|
-- https://github.com/davidm/lua-glob-pattern
|
|
-- https://stackoverflow.com/questions/1976007/what-characters-are-forbidden-in-windows-and-linux-directory-names
|
|
-- function M.glob_to_regex(glob)
|
|
-- end
|
|
|
|
--- Apply the TextEdit response.
|
|
-- @params TextEdit [table] see https://microsoft.github.io/language-server-protocol/specification
|
|
function M.text_document_apply_text_edit(text_edit, bufnr)
|
|
bufnr = resolve_bufnr(bufnr)
|
|
local range = text_edit.range
|
|
local start = range.start
|
|
local finish = range['end']
|
|
local new_lines = split_lines(text_edit.newText)
|
|
if start.character == 0 and finish.character == 0 then
|
|
api.nvim_buf_set_lines(bufnr, start.line, finish.line, false, new_lines)
|
|
return
|
|
end
|
|
local lines = api.nvim_buf_get_lines(bufnr, start.line, finish.line + 1, false)
|
|
local suffix = lines[#lines]:sub(finish.character+1)
|
|
local prefix = lines[1]:sub(1, start.character)
|
|
new_lines[#new_lines] = new_lines[#new_lines]..suffix
|
|
new_lines[1] = prefix..new_lines[1]
|
|
api.nvim_buf_set_lines(bufnr, start.line, finish.line + 1, false, new_lines)
|
|
end
|
|
|
|
-- textDocument/completion response returns one of CompletionItem[], CompletionList or null.
|
|
-- https://microsoft.github.io/language-server-protocol/specification#textDocument_completion
|
|
function M.extract_completion_items(result)
|
|
if type(result) == 'table' and result.items then
|
|
return result.items
|
|
elseif result ~= nil then
|
|
return result
|
|
else
|
|
return {}
|
|
end
|
|
end
|
|
|
|
--- Apply the TextDocumentEdit response.
|
|
-- @params TextDocumentEdit [table] see https://microsoft.github.io/language-server-protocol/specification
|
|
function M.text_document_apply_text_document_edit(text_document_edit, bufnr)
|
|
-- local text_document = text_document_edit.textDocument
|
|
-- TODO use text_document_version?
|
|
-- local text_document_version = text_document.version
|
|
|
|
-- TODO technically, you could do this without doing multiple buf_get/set
|
|
-- by getting the full region (smallest line and largest line) and doing
|
|
-- the edits on the buffer, and then applying the buffer at the end.
|
|
-- I'm not sure if that's better.
|
|
for _, text_edit in ipairs(text_document_edit.edits) do
|
|
M.text_document_apply_text_edit(text_edit, bufnr)
|
|
end
|
|
end
|
|
|
|
function M.get_current_line_to_cursor()
|
|
local pos = api.nvim_win_get_cursor(0)
|
|
local line = assert(api.nvim_buf_get_lines(0, pos[1]-1, pos[1], false)[1])
|
|
return line:sub(pos[2]+1)
|
|
end
|
|
|
|
--- Getting vim complete-items with incomplete flag.
|
|
-- @params CompletionItem[], CompletionList or nil (https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
|
|
-- @return { matches = complete-items table, incomplete = boolean }
|
|
function M.text_document_completion_list_to_complete_items(result, line_prefix)
|
|
local items = M.extract_completion_items(result)
|
|
if vim.tbl_isempty(items) then
|
|
return {}
|
|
end
|
|
-- Only initialize if we have some items.
|
|
if not line_prefix then
|
|
line_prefix = M.get_current_line_to_cursor()
|
|
end
|
|
|
|
local matches = {}
|
|
|
|
for _, completion_item in ipairs(items) do
|
|
local info = ' '
|
|
local documentation = completion_item.documentation
|
|
if documentation then
|
|
if type(documentation) == 'string' and documentation ~= '' then
|
|
info = documentation
|
|
elseif type(documentation) == 'table' and type(documentation.value) == 'string' then
|
|
info = documentation.value
|
|
-- else
|
|
-- TODO(ashkan) Validation handling here?
|
|
end
|
|
end
|
|
|
|
local word = completion_item.insertText or completion_item.label
|
|
|
|
-- Ref: `:h complete-items`
|
|
table.insert(matches, {
|
|
word = remove_prefix(line_prefix, word),
|
|
abbr = completion_item.label,
|
|
kind = protocol.CompletionItemKind[completion_item.kind] or '',
|
|
menu = completion_item.detail or '',
|
|
info = info,
|
|
icase = 1,
|
|
dup = 0,
|
|
empty = 1,
|
|
})
|
|
end
|
|
|
|
return matches
|
|
end
|
|
|
|
-- @params WorkspaceEdit [table] see https://microsoft.github.io/language-server-protocol/specification
|
|
function M.workspace_apply_workspace_edit(workspace_edit)
|
|
if workspace_edit.documentChanges then
|
|
for _, change in ipairs(workspace_edit.documentChanges) do
|
|
if change.kind then
|
|
-- TODO(ashkan) handle CreateFile/RenameFile/DeleteFile
|
|
error(string.format("Unsupported change: %q", vim.inspect(change)))
|
|
else
|
|
M.text_document_apply_text_document_edit(change)
|
|
end
|
|
end
|
|
return
|
|
end
|
|
|
|
local all_changes = workspace_edit.changes
|
|
if not (all_changes and not vim.tbl_isempty(all_changes)) then
|
|
return
|
|
end
|
|
|
|
for uri, changes in pairs(all_changes) do
|
|
local bufnr = vim.uri_to_bufnr(uri)
|
|
for _, change in ipairs(changes) do
|
|
M.text_document_apply_text_edit(change, bufnr)
|
|
end
|
|
end
|
|
end
|
|
|
|
--- Convert any of MarkedString | MarkedString[] | MarkupContent into markdown text lines
|
|
-- see https://microsoft.github.io/language-server-protocol/specifications/specification-3-14/#textDocument_hover
|
|
-- Useful for textDocument/hover, textDocument/signatureHelp, and potentially others.
|
|
function M.convert_input_to_markdown_lines(input, contents)
|
|
contents = contents or {}
|
|
-- MarkedString variation 1
|
|
if type(input) == 'string' then
|
|
list_extend(contents, split_lines(input))
|
|
else
|
|
assert(type(input) == 'table', "Expected a table for Hover.contents")
|
|
-- MarkupContent
|
|
if input.kind then
|
|
-- The kind can be either plaintext or markdown. However, either way we
|
|
-- will just be rendering markdown, so we handle them both the same way.
|
|
-- TODO these can have escaped/sanitized html codes in markdown. We
|
|
-- should make sure we handle this correctly.
|
|
|
|
-- Some servers send input.value as empty, so let's ignore this :(
|
|
-- assert(type(input.value) == 'string')
|
|
list_extend(contents, split_lines(input.value or ''))
|
|
-- MarkupString variation 2
|
|
elseif input.language then
|
|
-- Some servers send input.value as empty, so let's ignore this :(
|
|
-- assert(type(input.value) == 'string')
|
|
table.insert(contents, "```"..input.language)
|
|
list_extend(contents, split_lines(input.value or ''))
|
|
table.insert(contents, "```")
|
|
-- By deduction, this must be MarkedString[]
|
|
else
|
|
-- Use our existing logic to handle MarkedString
|
|
for _, marked_string in ipairs(input) do
|
|
M.convert_input_to_markdown_lines(marked_string, contents)
|
|
end
|
|
end
|
|
end
|
|
if contents[1] == '' or contents[1] == nil then
|
|
return {}
|
|
end
|
|
return contents
|
|
end
|
|
|
|
function M.make_floating_popup_options(width, height, opts)
|
|
validate {
|
|
opts = { opts, 't', true };
|
|
}
|
|
opts = opts or {}
|
|
validate {
|
|
["opts.offset_x"] = { opts.offset_x, 'n', true };
|
|
["opts.offset_y"] = { opts.offset_y, 'n', true };
|
|
}
|
|
|
|
local anchor = ''
|
|
local row, col
|
|
|
|
if vim.fn.winline() <= height then
|
|
anchor = anchor..'N'
|
|
row = 1
|
|
else
|
|
anchor = anchor..'S'
|
|
row = 0
|
|
end
|
|
|
|
if vim.fn.wincol() + width <= api.nvim_get_option('columns') then
|
|
anchor = anchor..'W'
|
|
col = 0
|
|
else
|
|
anchor = anchor..'E'
|
|
col = 1
|
|
end
|
|
|
|
return {
|
|
anchor = anchor,
|
|
col = col + (opts.offset_x or 0),
|
|
height = height,
|
|
relative = 'cursor',
|
|
row = row + (opts.offset_y or 0),
|
|
style = 'minimal',
|
|
width = width,
|
|
}
|
|
end
|
|
|
|
function M.open_floating_preview(contents, filetype, opts)
|
|
validate {
|
|
contents = { contents, 't' };
|
|
filetype = { filetype, 's', true };
|
|
opts = { opts, 't', true };
|
|
}
|
|
opts = opts or {}
|
|
|
|
-- Trim empty lines from the end.
|
|
contents = M.trim_empty_lines(contents)
|
|
|
|
local width = opts.width
|
|
local height = opts.height or #contents
|
|
if not width then
|
|
width = 0
|
|
for i, line in ipairs(contents) do
|
|
-- Clean up the input and add left pad.
|
|
line = " "..line:gsub("\r", "")
|
|
-- TODO(ashkan) use nvim_strdisplaywidth if/when that is introduced.
|
|
local line_width = vim.fn.strdisplaywidth(line)
|
|
width = math.max(line_width, width)
|
|
contents[i] = line
|
|
end
|
|
-- Add right padding of 1 each.
|
|
width = width + 1
|
|
end
|
|
|
|
local floating_bufnr = api.nvim_create_buf(false, true)
|
|
if filetype then
|
|
api.nvim_buf_set_option(floating_bufnr, 'filetype', filetype)
|
|
end
|
|
local float_option = M.make_floating_popup_options(width, height, opts)
|
|
local floating_winnr = api.nvim_open_win(floating_bufnr, false, float_option)
|
|
if filetype == 'markdown' then
|
|
api.nvim_win_set_option(floating_winnr, 'conceallevel', 2)
|
|
end
|
|
api.nvim_buf_set_lines(floating_bufnr, 0, -1, true, contents)
|
|
api.nvim_buf_set_option(floating_bufnr, 'modifiable', false)
|
|
api.nvim_command("autocmd CursorMoved <buffer> ++once lua pcall(vim.api.nvim_win_close, "..floating_winnr..", true)")
|
|
return floating_bufnr, floating_winnr
|
|
end
|
|
|
|
local function validate_lsp_position(pos)
|
|
validate { pos = {pos, 't'} }
|
|
validate {
|
|
line = {pos.line, 'n'};
|
|
character = {pos.character, 'n'};
|
|
}
|
|
return true
|
|
end
|
|
|
|
function M.open_floating_peek_preview(bufnr, start, finish, opts)
|
|
validate {
|
|
bufnr = {bufnr, 'n'};
|
|
start = {start, validate_lsp_position, 'valid start Position'};
|
|
finish = {finish, validate_lsp_position, 'valid finish Position'};
|
|
opts = { opts, 't', true };
|
|
}
|
|
local width = math.max(finish.character - start.character + 1, 1)
|
|
local height = math.max(finish.line - start.line + 1, 1)
|
|
local floating_winnr = api.nvim_open_win(bufnr, false, M.make_floating_popup_options(width, height, opts))
|
|
api.nvim_win_set_cursor(floating_winnr, {start.line+1, start.character})
|
|
api.nvim_command("autocmd CursorMoved * ++once lua pcall(vim.api.nvim_win_close, "..floating_winnr..", true)")
|
|
return floating_winnr
|
|
end
|
|
|
|
|
|
local function highlight_range(bufnr, ns, hiname, start, finish)
|
|
if start[1] == finish[1] then
|
|
-- TODO care about encoding here since this is in byte index?
|
|
api.nvim_buf_add_highlight(bufnr, ns, hiname, start[1], start[2], finish[2])
|
|
else
|
|
api.nvim_buf_add_highlight(bufnr, ns, hiname, start[1], start[2], -1)
|
|
for line = start[1] + 1, finish[1] - 1 do
|
|
api.nvim_buf_add_highlight(bufnr, ns, hiname, line, 0, -1)
|
|
end
|
|
api.nvim_buf_add_highlight(bufnr, ns, hiname, finish[1], 0, finish[2])
|
|
end
|
|
end
|
|
|
|
do
|
|
local all_buffer_diagnostics = {}
|
|
|
|
local diagnostic_ns = api.nvim_create_namespace("vim_lsp_diagnostics")
|
|
|
|
local default_severity_highlight = {
|
|
[protocol.DiagnosticSeverity.Error] = { guifg = "Red" };
|
|
[protocol.DiagnosticSeverity.Warning] = { guifg = "Orange" };
|
|
[protocol.DiagnosticSeverity.Information] = { guifg = "LightBlue" };
|
|
[protocol.DiagnosticSeverity.Hint] = { guifg = "LightGrey" };
|
|
}
|
|
|
|
local underline_highlight_name = "LspDiagnosticsUnderline"
|
|
api.nvim_command(string.format("highlight %s gui=underline cterm=underline", underline_highlight_name))
|
|
|
|
local function find_color_rgb(color)
|
|
local rgb_hex = api.nvim_get_color_by_name(color)
|
|
validate { color = {color, function() return rgb_hex ~= -1 end, "valid color name"} }
|
|
return rgb_hex
|
|
end
|
|
|
|
--- Determine whether to use black or white text
|
|
-- Ref: https://stackoverflow.com/a/1855903/837964
|
|
-- https://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color
|
|
local function color_is_bright(r, g, b)
|
|
-- Counting the perceptive luminance - human eye favors green color
|
|
local luminance = (0.299*r + 0.587*g + 0.114*b)/255
|
|
if luminance > 0.5 then
|
|
return true -- Bright colors, black font
|
|
else
|
|
return false -- Dark colors, white font
|
|
end
|
|
end
|
|
|
|
local severity_highlights = {}
|
|
|
|
function M.set_severity_highlights(highlights)
|
|
validate {highlights = {highlights, 't'}}
|
|
for severity, default_color in pairs(default_severity_highlight) do
|
|
local severity_name = protocol.DiagnosticSeverity[severity]
|
|
local highlight_name = "LspDiagnostics"..severity_name
|
|
local hi_info = highlights[severity] or default_color
|
|
-- Try to fill in the foreground color with a sane default.
|
|
if not hi_info.guifg and hi_info.guibg then
|
|
-- TODO(ashkan) move this out when bitop is guaranteed to be included.
|
|
local bit = require 'bit'
|
|
local band, rshift = bit.band, bit.rshift
|
|
local rgb = find_color_rgb(hi_info.guibg)
|
|
local is_bright = color_is_bright(rshift(rgb, 16), band(rshift(rgb, 8), 0xFF), band(rgb, 0xFF))
|
|
hi_info.guifg = is_bright and "Black" or "White"
|
|
end
|
|
if not hi_info.ctermfg and hi_info.ctermbg then
|
|
-- TODO(ashkan) move this out when bitop is guaranteed to be included.
|
|
local bit = require 'bit'
|
|
local band, rshift = bit.band, bit.rshift
|
|
local rgb = find_color_rgb(hi_info.ctermbg)
|
|
local is_bright = color_is_bright(rshift(rgb, 16), band(rshift(rgb, 8), 0xFF), band(rgb, 0xFF))
|
|
hi_info.ctermfg = is_bright and "Black" or "White"
|
|
end
|
|
local cmd_parts = {"highlight", highlight_name}
|
|
for k, v in pairs(hi_info) do
|
|
table.insert(cmd_parts, k.."="..v)
|
|
end
|
|
api.nvim_command(table.concat(cmd_parts, ' '))
|
|
severity_highlights[severity] = highlight_name
|
|
end
|
|
end
|
|
|
|
function M.buf_clear_diagnostics(bufnr)
|
|
validate { bufnr = {bufnr, 'n', true} }
|
|
bufnr = bufnr == 0 and api.nvim_get_current_buf() or bufnr
|
|
api.nvim_buf_clear_namespace(bufnr, diagnostic_ns, 0, -1)
|
|
end
|
|
|
|
-- Initialize with the defaults.
|
|
M.set_severity_highlights(default_severity_highlight)
|
|
|
|
function M.get_severity_highlight_name(severity)
|
|
return severity_highlights[severity]
|
|
end
|
|
|
|
function M.show_line_diagnostics()
|
|
local bufnr = api.nvim_get_current_buf()
|
|
local line = api.nvim_win_get_cursor(0)[1] - 1
|
|
-- local marks = api.nvim_buf_get_extmarks(bufnr, diagnostic_ns, {line, 0}, {line, -1}, {})
|
|
-- if #marks == 0 then
|
|
-- return
|
|
-- end
|
|
-- local buffer_diagnostics = all_buffer_diagnostics[bufnr]
|
|
local lines = {"Diagnostics:"}
|
|
local highlights = {{0, "Bold"}}
|
|
|
|
local buffer_diagnostics = all_buffer_diagnostics[bufnr]
|
|
if not buffer_diagnostics then return end
|
|
local line_diagnostics = buffer_diagnostics[line]
|
|
if not line_diagnostics then return end
|
|
|
|
for i, diagnostic in ipairs(line_diagnostics) do
|
|
-- for i, mark in ipairs(marks) do
|
|
-- local mark_id = mark[1]
|
|
-- local diagnostic = buffer_diagnostics[mark_id]
|
|
|
|
-- TODO(ashkan) make format configurable?
|
|
local prefix = string.format("%d. ", i)
|
|
local hiname = severity_highlights[diagnostic.severity]
|
|
local message_lines = split_lines(diagnostic.message)
|
|
table.insert(lines, prefix..message_lines[1])
|
|
table.insert(highlights, {#prefix + 1, hiname})
|
|
for j = 2, #message_lines do
|
|
table.insert(lines, message_lines[j])
|
|
table.insert(highlights, {0, hiname})
|
|
end
|
|
end
|
|
local popup_bufnr, winnr = M.open_floating_preview(lines, 'plaintext')
|
|
for i, hi in ipairs(highlights) do
|
|
local prefixlen, hiname = unpack(hi)
|
|
-- Start highlight after the prefix
|
|
api.nvim_buf_add_highlight(popup_bufnr, -1, hiname, i-1, prefixlen, -1)
|
|
end
|
|
return popup_bufnr, winnr
|
|
end
|
|
|
|
function M.buf_diagnostics_save_positions(bufnr, diagnostics)
|
|
validate {
|
|
bufnr = {bufnr, 'n', true};
|
|
diagnostics = {diagnostics, 't', true};
|
|
}
|
|
if not diagnostics then return end
|
|
bufnr = bufnr == 0 and api.nvim_get_current_buf() or bufnr
|
|
|
|
if not all_buffer_diagnostics[bufnr] then
|
|
-- Clean up our data when the buffer unloads.
|
|
api.nvim_buf_attach(bufnr, false, {
|
|
on_detach = function(b)
|
|
all_buffer_diagnostics[b] = nil
|
|
end
|
|
})
|
|
end
|
|
all_buffer_diagnostics[bufnr] = {}
|
|
local buffer_diagnostics = all_buffer_diagnostics[bufnr]
|
|
|
|
for _, diagnostic in ipairs(diagnostics) do
|
|
local start = diagnostic.range.start
|
|
-- local mark_id = api.nvim_buf_set_extmark(bufnr, diagnostic_ns, 0, start.line, 0, {})
|
|
-- buffer_diagnostics[mark_id] = diagnostic
|
|
local line_diagnostics = buffer_diagnostics[start.line]
|
|
if not line_diagnostics then
|
|
line_diagnostics = {}
|
|
buffer_diagnostics[start.line] = line_diagnostics
|
|
end
|
|
table.insert(line_diagnostics, diagnostic)
|
|
end
|
|
end
|
|
|
|
|
|
function M.buf_diagnostics_underline(bufnr, diagnostics)
|
|
for _, diagnostic in ipairs(diagnostics) do
|
|
local start = diagnostic.range.start
|
|
local finish = diagnostic.range["end"]
|
|
|
|
-- TODO care about encoding here since this is in byte index?
|
|
highlight_range(bufnr, diagnostic_ns, underline_highlight_name,
|
|
{start.line, start.character},
|
|
{finish.line, finish.character}
|
|
)
|
|
end
|
|
end
|
|
|
|
function M.buf_diagnostics_virtual_text(bufnr, diagnostics)
|
|
local buffer_line_diagnostics = all_buffer_diagnostics[bufnr]
|
|
if not buffer_line_diagnostics then
|
|
M.buf_diagnostics_save_positions(bufnr, diagnostics)
|
|
end
|
|
buffer_line_diagnostics = all_buffer_diagnostics[bufnr]
|
|
if not buffer_line_diagnostics then
|
|
return
|
|
end
|
|
for line, line_diags in pairs(buffer_line_diagnostics) do
|
|
local virt_texts = {}
|
|
for i = 1, #line_diags - 1 do
|
|
table.insert(virt_texts, {"■", severity_highlights[line_diags[i].severity]})
|
|
end
|
|
local last = line_diags[#line_diags]
|
|
-- TODO(ashkan) use first line instead of subbing 2 spaces?
|
|
table.insert(virt_texts, {"■ "..last.message:gsub("\r", ""):gsub("\n", " "), severity_highlights[last.severity]})
|
|
api.nvim_buf_set_virtual_text(bufnr, diagnostic_ns, line, virt_texts, {})
|
|
end
|
|
end
|
|
end
|
|
|
|
function M.buf_loclist(bufnr, locations)
|
|
local targetwin
|
|
for _, winnr in ipairs(api.nvim_list_wins()) do
|
|
local winbuf = api.nvim_win_get_buf(winnr)
|
|
if winbuf == bufnr then
|
|
targetwin = winnr
|
|
break
|
|
end
|
|
end
|
|
if not targetwin then return end
|
|
|
|
local items = {}
|
|
local path = api.nvim_buf_get_name(bufnr)
|
|
for _, d in ipairs(locations) do
|
|
-- TODO: URL parsing here?
|
|
local start = d.range.start
|
|
table.insert(items, {
|
|
filename = path,
|
|
lnum = start.line + 1,
|
|
col = start.character + 1,
|
|
text = d.message,
|
|
})
|
|
end
|
|
vim.fn.setloclist(targetwin, items, ' ', 'Language Server')
|
|
end
|
|
|
|
-- Remove empty lines from the beginning and end.
|
|
function M.trim_empty_lines(lines)
|
|
local result = {}
|
|
local start = 1
|
|
for i = 1, #lines do
|
|
if #lines[i] > 0 then
|
|
start = i
|
|
break
|
|
end
|
|
end
|
|
local finish = 1
|
|
for i = #lines, 1, -1 do
|
|
if #lines[i] > 0 then
|
|
finish = i
|
|
break
|
|
end
|
|
end
|
|
-- TODO(ashkan) use tbl_slice.
|
|
for i = start, finish do
|
|
table.insert(result, lines[i])
|
|
end
|
|
return result
|
|
end
|
|
|
|
-- Accepts markdown lines and tries to reduce it to a filetype if it is
|
|
-- just a single code block.
|
|
-- Note: This modifies the input.
|
|
--
|
|
-- Returns: filetype or 'markdown' if it was unchanged.
|
|
function M.try_trim_markdown_code_blocks(lines)
|
|
local language_id = lines[1]:match("^```(.*)")
|
|
if language_id then
|
|
local has_inner_code_fence = false
|
|
for i = 2, (#lines - 1) do
|
|
local line = lines[i]
|
|
if line:sub(1,3) == '```' then
|
|
has_inner_code_fence = true
|
|
break
|
|
end
|
|
end
|
|
-- No inner code fences + starting with code fence = hooray.
|
|
if not has_inner_code_fence then
|
|
table.remove(lines, 1)
|
|
table.remove(lines)
|
|
return language_id
|
|
end
|
|
end
|
|
return 'markdown'
|
|
end
|
|
|
|
|
|
return M
|
|
-- vim:sw=2 ts=2 et
|