Operate at event buffer level. Be more clever with autocommands.

# Details

Previously all operations assumed only the current buffer was being
interacted with.

This can lead to poor behavior when interacting with multiple markdown
buffers. For instance toggling would only change the current buffer but
a buffer open in a separate window would still be rendered and stop
being updated since enable / disable is a global operation. nvim_cmp
popup windows do not change the current buffer so would trigger a
re-render event though no content actually changes.

To get around this use the buffer from events when making changes.

By applying the validation logic on these buffers we avoid doing work
where previously we were.

To make toggling propagate through all buffers use nvim_list_bufs
method.

Additionally there 2 events the provide information that can be
used to improve rendering.

- ModeChanged tells us the start and end mode which we can use to
  avoid re-rendering when the change has no impact. I.e. going from
  normal mode to command mode should not do anything.
- WinResized tells us all impacted windows which we can use to re-render
  all impacted buffers.

Author: MeanderingProgrammer

lua/render-markdown/handler/latex.lua

@@ -13,14 +13,15 @@ local M = {}
 
 ---@param namespace number
 ---@param root TSNode
-M.render = function(namespace, root)
+---@param buf integer
+M.render = function(namespace, root, buf)
     if vim.fn.executable('latex2text') ~= 1 then
         return
     end
 
-    local value = vim.treesitter.get_node_text(root, 0)
+    local value = vim.treesitter.get_node_text(root, buf)
     local start_row, start_col, end_row, end_col = root:range()
-    logger.debug_node('latex', root)
+    logger.debug_node('latex', root, buf)
 
     local expressions = cache.expressions[value]
     if expressions == nil then
@@ -33,7 +34,7 @@ M.render = function(namespace, root)
     local virt_lines = vim.tbl_map(function(expression)
         return { { expression, state.config.highlights.latex } }
     end, expressions)
-    vim.api.nvim_buf_set_extmark(0, namespace, start_row, start_col, {
+    vim.api.nvim_buf_set_extmark(buf, namespace, start_row, start_col, {
         end_row = end_row,
         end_col = end_col,
         virt_lines = virt_lines,

lua/render-markdown/handler/markdown.lua

@@ -1,19 +1,21 @@
 local list = require('render-markdown.list')
 local logger = require('render-markdown.logger')
 local state = require('render-markdown.state')
+local util = require('render-markdown.util')
 
 local M = {}
 
 ---@param namespace number
 ---@param root TSNode
-M.render = function(namespace, root)
+---@param buf integer
+M.render = function(namespace, root, buf)
     local highlights = state.config.highlights
     ---@diagnostic disable-next-line: missing-parameter
-    for id, node in state.markdown_query:iter_captures(root, 0) do
+    for id, node in state.markdown_query:iter_captures(root, buf) do
         local capture = state.markdown_query.captures[id]
-        local value = vim.treesitter.get_node_text(node, 0)
+        local value = vim.treesitter.get_node_text(node, buf)
         local start_row, start_col, end_row, end_col = node:range()
-        logger.debug_node(capture, node)
+        logger.debug_node(capture, node, buf)
 
         if capture == 'heading' then
             local level = #value
@@ -27,7 +29,7 @@ M.render = function(namespace, root)
             local foreground = list.clamp_last(highlights.heading.foregrounds, level)
 
             local virt_text = { string.rep(' ', padding) .. heading, { foreground, background } }
-            vim.api.nvim_buf_set_extmark(0, namespace, start_row, 0, {
+            vim.api.nvim_buf_set_extmark(buf, namespace, start_row, 0, {
                 end_row = end_row + 1,
                 end_col = 0,
                 hl_group = background,
@@ -36,14 +38,14 @@ M.render = function(namespace, root)
                 hl_eol = true,
             })
         elseif capture == 'dash' then
-            local width = vim.api.nvim_win_get_width(0)
+            local width = vim.api.nvim_win_get_width(util.buf_to_win(buf))
             local virt_text = { state.config.dash:rep(width), highlights.dash }
-            vim.api.nvim_buf_set_extmark(0, namespace, start_row, 0, {
+            vim.api.nvim_buf_set_extmark(buf, namespace, start_row, 0, {
                 virt_text = { virt_text },
                 virt_text_pos = 'overlay',
             })
         elseif capture == 'code' then
-            vim.api.nvim_buf_set_extmark(0, namespace, start_row, 0, {
+            vim.api.nvim_buf_set_extmark(buf, namespace, start_row, 0, {
                 end_row = end_row,
                 end_col = 0,
                 hl_group = highlights.code,
@@ -65,15 +67,15 @@ M.render = function(namespace, root)
             end
 
             local virt_text = { list_marker_overlay, highlights.bullet }
-            vim.api.nvim_buf_set_extmark(0, namespace, start_row, start_col, {
+            vim.api.nvim_buf_set_extmark(buf, namespace, start_row, start_col, {
                 end_row = end_row,
                 end_col = end_col,
                 virt_text = { virt_text },
                 virt_text_pos = 'overlay',
             })
         elseif capture == 'quote_marker' then
             local virt_text = { value:gsub('>', state.config.quote), highlights.quote }
-            vim.api.nvim_buf_set_extmark(0, namespace, start_row, start_col, {
+            vim.api.nvim_buf_set_extmark(buf, namespace, start_row, start_col, {
                 end_row = end_row,
                 end_col = end_col,
                 virt_text = { virt_text },
@@ -90,7 +92,7 @@ M.render = function(namespace, root)
 
             if padding >= 0 then
                 local virt_text = { string.rep(' ', padding) .. checkbox, highlight }
-                vim.api.nvim_buf_set_extmark(0, namespace, start_row, start_col, {
+                vim.api.nvim_buf_set_extmark(buf, namespace, start_row, start_col, {
                     end_row = end_row,
                     end_col = end_col,
                     virt_text = { virt_text },
@@ -99,7 +101,7 @@ M.render = function(namespace, root)
             end
         elseif capture == 'table' then
             if state.config.fat_tables then
-                local lines = vim.api.nvim_buf_get_lines(0, start_row, end_row, false)
+                local lines = vim.api.nvim_buf_get_lines(buf, start_row, end_row, false)
                 local table_head = list.first(lines)
                 local table_tail = list.last(lines)
                 if #table_head == #table_tail then
@@ -109,13 +111,13 @@ M.render = function(namespace, root)
                     end, headings)
 
                     local line_above = { { '┌' .. table.concat(sections, '┬') .. '┐', highlights.table.head } }
-                    vim.api.nvim_buf_set_extmark(0, namespace, start_row, start_col, {
+                    vim.api.nvim_buf_set_extmark(buf, namespace, start_row, start_col, {
                         virt_lines_above = true,
                         virt_lines = { line_above },
                     })
 
                     local line_below = { { '└' .. table.concat(sections, '┴') .. '┘', highlights.table.row } }
-                    vim.api.nvim_buf_set_extmark(0, namespace, end_row, start_col, {
+                    vim.api.nvim_buf_set_extmark(buf, namespace, end_row, start_col, {
                         virt_lines_above = true,
                         virt_lines = { line_below },
                     })
@@ -138,7 +140,7 @@ M.render = function(namespace, root)
             end
 
             local virt_text = { row, highlight }
-            vim.api.nvim_buf_set_extmark(0, namespace, start_row, start_col, {
+            vim.api.nvim_buf_set_extmark(buf, namespace, start_row, start_col, {
                 end_row = end_row,
                 end_col = end_col,
                 virt_text = { virt_text },

lua/render-markdown/handler/markdown_inline.lua

@@ -5,16 +5,17 @@ local M = {}
 
 ---@param namespace number
 ---@param root TSNode
-M.render = function(namespace, root)
+---@param buf integer
+M.render = function(namespace, root, buf)
     local highlights = state.config.highlights
     ---@diagnostic disable-next-line: missing-parameter
-    for id, node in state.inline_query:iter_captures(root, 0) do
+    for id, node in state.inline_query:iter_captures(root, buf) do
         local capture = state.inline_query.captures[id]
         local start_row, start_col, end_row, end_col = node:range()
-        logger.debug_node(capture, node)
+        logger.debug_node(capture, node, buf)
 
         if capture == 'code' then
-            vim.api.nvim_buf_set_extmark(0, namespace, start_row, start_col, {
+            vim.api.nvim_buf_set_extmark(buf, namespace, start_row, start_col, {
                 end_row = end_row,
                 end_col = end_col,
                 hl_group = highlights.code,

lua/render-markdown/init.lua

@@ -1,5 +1,6 @@
 local state = require('render-markdown.state')
 local ui = require('render-markdown.ui')
+local util = require('render-markdown.util')
 
 local M = {}
 
@@ -139,18 +140,42 @@ function M.setup(opts)
     state.inline_query = vim.treesitter.query.parse('markdown_inline', state.config.inline_query)
 
     -- Call immediately to re-render on LazyReload
-    vim.schedule(ui.refresh)
-
-    vim.api.nvim_create_autocmd({
-        'FileChangedShellPost',
-        'ModeChanged',
-        'Syntax',
-        'TextChanged',
-        'WinResized',
-    }, {
-        group = vim.api.nvim_create_augroup('RenderMarkdown', { clear = true }),
+    vim.schedule(function()
+        ui.refresh(vim.api.nvim_get_current_buf())
+    end)
+
+    local group = vim.api.nvim_create_augroup('RenderMarkdown', { clear = true })
+    vim.api.nvim_create_autocmd({ 'ModeChanged' }, {
+        group = group,
+        callback = function(event)
+            local was_rendered = vim.tbl_contains(state.config.render_modes, vim.v.event.old_mode)
+            local should_render = vim.tbl_contains(state.config.render_modes, vim.v.event.new_mode)
+            -- Only need to re-render if render state is changing. I.e. going from normal mode to
+            -- command mode with the default config, both are rendered, so no point re-rendering
+            if was_rendered ~= should_render then
+                vim.schedule(function()
+                    ui.refresh(event.buf)
+                end)
+            end
+        end,
+    })
+    vim.api.nvim_create_autocmd({ 'WinResized' }, {
+        group = group,
         callback = function()
-            vim.schedule(ui.refresh)
+            for _, win in ipairs(vim.v.event.windows) do
+                local buf = util.win_to_buf(win)
+                vim.schedule(function()
+                    ui.refresh(buf)
+                end)
+            end
+        end,
+    })
+    vim.api.nvim_create_autocmd({ 'FileChangedShellPost', 'Syntax', 'TextChanged' }, {
+        group = group,
+        callback = function(event)
+            vim.schedule(function()
+                ui.refresh(event.buf)
+            end)
         end,
     })
 
@@ -162,13 +187,15 @@ function M.setup(opts)
 end
 
 M.toggle = function()
-    if state.enabled then
-        state.enabled = false
-        vim.schedule(ui.clear)
-    else
-        state.enabled = true
-        -- Call to refresh must happen after state change
-        vim.schedule(ui.refresh)
+    state.enabled = not state.enabled
+    for _, buf in ipairs(vim.api.nvim_list_bufs()) do
+        vim.schedule(function()
+            if state.enabled then
+                ui.refresh(buf)
+            else
+                ui.clear_valid(buf)
+            end
+        end)
     end
 end
 

lua/render-markdown/logger.lua

@@ -59,9 +59,10 @@ end
 
 ---@param capture string
 ---@param node TSNode
-M.debug_node = function(capture, node)
+---@param buf integer
+M.debug_node = function(capture, node, buf)
     if vim.tbl_contains({ 'debug' }, state.config.log_level) then
-        local value = vim.treesitter.get_node_text(node, 0)
+        local value = vim.treesitter.get_node_text(node, buf)
         local start_row, start_col, end_row, end_col = node:range()
         log.add('debug', {
             capture = capture,

lua/render-markdown/ui.lua

@@ -3,64 +3,62 @@ local logger = require('render-markdown.logger')
 local markdown = require('render-markdown.handler.markdown')
 local markdown_inline = require('render-markdown.handler.markdown_inline')
 local state = require('render-markdown.state')
+local util = require('render-markdown.util')
 
 local M = {}
 
 M.namespace = vim.api.nvim_create_namespace('render-markdown.nvim')
 
-M.clear = function()
-    -- Remove existing highlights / virtual text
-    vim.api.nvim_buf_clear_namespace(0, M.namespace, 0, -1)
-    vim.opt_local.conceallevel = state.config.conceal.default
-end
-
-M.refresh = function()
+---@param buf integer
+M.refresh = function(buf)
     if not state.enabled then
         return
     end
-    if not vim.tbl_contains(state.config.file_types, vim.bo.filetype) then
+    if not M.clear_valid(buf) then
         return
     end
-    -- Needs to happen after file_type check and before mode check
-    M.clear()
     if not vim.tbl_contains(state.config.render_modes, vim.fn.mode()) then
         return
     end
-    if M.file_size_mb() > state.config.max_file_size then
+    if util.file_size_mb(buf) > state.config.max_file_size then
         return
     end
 
     logger.start()
-    vim.opt_local.conceallevel = state.config.conceal.rendered
+    util.set_conceal(buf, state.config.conceal.rendered)
 
     -- Make sure injections are processed
-    vim.treesitter.get_parser():parse(true)
+    vim.treesitter.get_parser(buf):parse(true)
 
-    vim.treesitter.get_parser():for_each_tree(function(tree, language_tree)
+    vim.treesitter.get_parser(buf):for_each_tree(function(tree, language_tree)
         local language = language_tree:lang()
         logger.debug({ language = language })
         if language == 'markdown' then
-            markdown.render(M.namespace, tree:root())
+            markdown.render(M.namespace, tree:root(), buf)
         elseif language == 'markdown_inline' then
-            markdown_inline.render(M.namespace, tree:root())
+            markdown_inline.render(M.namespace, tree:root(), buf)
         elseif language == 'latex' then
-            latex.render(M.namespace, tree:root())
+            latex.render(M.namespace, tree:root(), buf)
         else
             logger.debug('No handler found')
         end
     end)
     logger.flush()
 end
 
----@return number
-M.file_size_mb = function()
-    local ok, stats = pcall(function()
-        return vim.uv.fs_stat(vim.api.nvim_buf_get_name(0))
-    end)
-    if not (ok and stats) then
-        return 0
+--- Remove existing highlights / virtual text for valid buffers
+---@param buf integer
+---@return boolean
+M.clear_valid = function(buf)
+    if not vim.api.nvim_buf_is_valid(buf) then
+        return false
+    end
+    if not vim.tbl_contains(state.config.file_types, vim.bo[buf].filetype) then
+        return false
     end
-    return stats.size / (1024 * 1024)
+    vim.api.nvim_buf_clear_namespace(buf, M.namespace, 0, -1)
+    util.set_conceal(buf, state.config.conceal.default)
+    return true
 end
 
 return M

lua/render-markdown/util.lua

@@ -0,0 +1,34 @@
+local M = {}
+
+---@param win integer
+---@return integer
+M.win_to_buf = function(win)
+    return vim.fn.winbufnr(win)
+end
+
+---@param buf integer
+---@return integer
+M.buf_to_win = function(buf)
+    return vim.fn.bufwinid(buf)
+end
+
+---@param buf integer
+---@param value integer
+M.set_conceal = function(buf, value)
+    local win = M.buf_to_win(buf)
+    vim.api.nvim_set_option_value('conceallevel', value, { scope = 'local', win = win })
+end
+
+---@param buf integer
+---@return number
+M.file_size_mb = function(buf)
+    local ok, stats = pcall(function()
+        return vim.uv.fs_stat(vim.api.nvim_buf_get_name(buf))
+    end)
+    if not (ok and stats) then
+        return 0
+    end
+    return stats.size / (1024 * 1024)
+end
+
+return M