feat: support same buffer in multiple windows

Issue: #184

This plugin optimizes performance for large files by only attempting to
render what is visible in the window + some amount of buffer. This is
likely what users want in most instances however does not account for
the fact that the same file can be open in multiple windows at the same
time. When this occurs and one of the windows is scrolled the other
window will start losing decorations.

To account for this we now iterate through all windows for the current buffer
and collect all visible ranges. These ranges are coalesced based on any
overlaps. This is done in a new `range` module.

Much of the logic in the `context` module needed to be updated to
account for multiple ranges rather than a single top and bottom. This
was fairly easy for most things and involved adding a loop over the ranges.

It was convenient that all the range checking logic was centralized in
the `context` module and did not leak into any of the rendering logic,
so it seems like we have a good abstraction.

Since we went the more complicated route with the implementation
handling multiple ranges the performance impact should be negligible. It
should be none with a single window and as little as possible with
multiple windows since no matter what we will need to do more work to
render more lines.

Author: MeanderingProgrammer

CHANGELOG.md

@@ -18,6 +18,7 @@
 - heading margin / padding based on level [#182](https://github.com/MeanderingProgrammer/render-markdown.nvim/issues/182)
   & border virtual option [#183](https://github.com/MeanderingProgrammer/render-markdown.nvim/issues/183)
   [aad1a12](https://github.com/MeanderingProgrammer/render-markdown.nvim/commit/aad1a1220dc9da5757e3af3befbc7fc3869dd334)
+- config command to debug configurations [a9643f4](https://github.com/MeanderingProgrammer/render-markdown.nvim/commit/a9643f4377f39f4abf943fbc73be69f33f5f2f1d)
 
 ### Bug Fixes
 

lua/render-markdown/core/context.lua

@@ -1,13 +1,13 @@
 local NodeInfo = require('render-markdown.core.node_info')
+local Range = require('render-markdown.core.range')
 local log = require('render-markdown.core.log')
 local str = require('render-markdown.core.str')
 local util = require('render-markdown.core.util')
 
 ---@class render.md.Context
 ---@field private buf integer
 ---@field private win integer
----@field private top integer
----@field private bottom integer
+---@field private ranges render.md.Range[]
 ---@field private components table<integer, render.md.CustomComponent>
 ---@field private conceal? table<integer, [integer, integer][]>
 ---@field private links table<integer, [integer, integer, integer][]>
@@ -24,9 +24,15 @@ function Context.new(buf, win, offset)
     local self = setmetatable({}, Context)
     self.buf = buf
     self.win = win
-    local top = util.view(win).topline - 1
-    self.top = math.max(top - offset, 0)
-    self.bottom = self:compute_bottom(top, offset)
+
+    local ranges = { Context.compute_range(self.buf, self.win, offset) }
+    for _, window_id in ipairs(vim.fn.win_findbuf(buf)) do
+        if window_id ~= self.win then
+            table.insert(ranges, Context.compute_range(self.buf, window_id, offset))
+        end
+    end
+    self.ranges = Range.coalesce(ranges)
+
     self.components = {}
     self.conceal = nil
     self.links = {}
@@ -36,20 +42,25 @@ function Context.new(buf, win, offset)
 end
 
 ---@private
----@param top integer
+---@param buf integer
+---@param win integer
 ---@param offset integer
----@return integer
-function Context:compute_bottom(top, offset)
+---@return render.md.Range
+function Context.compute_range(buf, win, offset)
+    local top = util.view(win).topline - 1
+    top = math.max(top - offset, 0)
+
     local bottom = top
-    local lines = vim.api.nvim_buf_line_count(self.buf)
-    local target = vim.api.nvim_win_get_height(self.win) + offset
-    while bottom < lines and target > 0 do
+    local lines = vim.api.nvim_buf_line_count(buf)
+    local size = vim.api.nvim_win_get_height(win) + offset
+    while bottom < lines and size > 0 do
         bottom = bottom + 1
-        if util.visible(self.win, bottom) then
-            target = target - 1
+        if util.visible(win, bottom) then
+            size = size - 1
         end
     end
-    return bottom
+
+    return Range.new(top, bottom)
 end
 
 ---@param info render.md.NodeInfo
@@ -124,39 +135,62 @@ function Context:get_width()
     return self.window_width
 end
 
----@param other render.md.Context
+---@param win integer
 ---@return boolean
-function Context:contains_range(other)
-    return self.top <= other.top and self.bottom >= other.bottom
+function Context:contains_window(win)
+    local window_range = Context.compute_range(self.buf, win, 0)
+    for _, range in ipairs(self.ranges) do
+        if range:contains(window_range) then
+            return true
+        end
+    end
+    return false
 end
 
----@return Range2
-function Context:range()
-    return { self.top, self.bottom }
+---@private
+---@param top integer
+---@param bottom integer
+---@return boolean
+function Context:overlap(top, bottom)
+    for _, range in ipairs(self.ranges) do
+        if range:overlaps(top, bottom) then
+            return true
+        end
+    end
+    return false
 end
 
 ---@param node TSNode
 ---@return boolean
 function Context:contains_node(node)
     local top, _, bottom, _ = node:range()
-    return top < self.bottom and bottom >= self.top
+    return self:overlap(top, bottom)
 end
 
 ---@param info render.md.NodeInfo
 ---@return boolean
 function Context:contains_info(info)
-    return info.start_row < self.bottom and info.end_row >= self.top
+    return self:overlap(info.start_row, info.end_row)
+end
+
+---@param parser vim.treesitter.LanguageTree
+function Context:parse(parser)
+    for _, range in ipairs(self.ranges) do
+        parser:parse({ range.top, range.bottom })
+    end
 end
 
 ---@param root TSNode
 ---@param query vim.treesitter.Query
 ---@param callback fun(capture: string, node: render.md.NodeInfo)
 function Context:query(root, query, callback)
-    for id, node in query:iter_captures(root, self.buf, self.top, self.bottom) do
-        local capture = query.captures[id]
-        local info = NodeInfo.new(self.buf, node)
-        log.node_info(capture, info)
-        callback(capture, info)
+    for _, range in ipairs(self.ranges) do
+        for id, node in query:iter_captures(root, self.buf, range.top, range.bottom) do
+            local capture = query.captures[id]
+            local info = NodeInfo.new(self.buf, node)
+            log.node_info(capture, info)
+            callback(capture, info)
+        end
     end
 end
 
@@ -207,7 +241,7 @@ function Context:compute_conceal()
     end
     local ranges = {}
     local parser = vim.treesitter.get_parser(self.buf)
-    parser:parse(self:range())
+    self:parse(parser)
     parser:for_each_tree(function(tree, language_tree)
         local nodes = self:compute_conceal_nodes(language_tree:lang(), tree:root())
         for _, node in ipairs(nodes) do
@@ -237,9 +271,11 @@ function Context:compute_conceal_nodes(language, root)
         return {}
     end
     local nodes = {}
-    for _, node, metadata in query:iter_captures(root, self.buf, self.top, self.bottom) do
-        if metadata.conceal ~= nil then
-            table.insert(nodes, node)
+    for _, range in ipairs(self.ranges) do
+        for _, node, metadata in query:iter_captures(root, self.buf, range.top, range.bottom) do
+            if metadata.conceal ~= nil then
+                table.insert(nodes, node)
+            end
         end
     end
     return nodes
@@ -265,7 +301,7 @@ function M.contains_range(buf, win)
     if context == nil then
         return false
     end
-    return context:contains_range(Context.new(buf, win, 0))
+    return context:contains_window(win)
 end
 
 ---@param buf integer

lua/render-markdown/core/range.lua

@@ -0,0 +1,60 @@
+---@class render.md.Range
+---@field top integer
+---@field bottom integer
+local Range = {}
+Range.__index = Range
+
+---@param top integer
+---@param bottom integer
+---@return render.md.Range
+function Range.new(top, bottom)
+    local self = setmetatable({}, Range)
+    self.top = top
+    self.bottom = bottom
+    return self
+end
+
+---@param a render.md.Range
+---@param b render.md.Range
+---@return boolean
+function Range.__lt(a, b)
+    if a.top ~= b.top then
+        return a.top < b.top
+    else
+        return a.bottom < b.bottom
+    end
+end
+
+---@param other render.md.Range
+---@return boolean
+function Range:contains(other)
+    return self.top <= other.top and self.bottom >= other.bottom
+end
+
+---@param top integer
+---@param bottom integer
+---@return boolean
+function Range:overlaps(top, bottom)
+    return top < self.bottom and bottom >= self.top
+end
+
+---@param ranges render.md.Range[]
+---@return render.md.Range[]
+function Range.coalesce(ranges)
+    if #ranges < 2 then
+        return ranges
+    end
+    table.sort(ranges)
+    local result = { ranges[1] }
+    for i = 2, #ranges do
+        local range, current = ranges[i], result[#result]
+        if range.top <= current.bottom + 1 then
+            current.bottom = math.max(current.bottom, range.bottom)
+        else
+            table.insert(result, range)
+        end
+    end
+    return result
+end
+
+return Range

lua/render-markdown/core/ui.lua

@@ -160,7 +160,7 @@ function M.parse_buffer(buf, win)
     -- Reset buffer context
     Context.reset(buf, win)
     -- Make sure injections are processed
-    parser:parse(Context.get(buf):range())
+    Context.get(buf):parse(parser)
     -- Parse markdown after all other nodes to take advantage of state
     local marks, markdown_roots = {}, {}
     parser:for_each_tree(function(tree, language_tree)

lua/render-markdown/health.lua

@@ -4,7 +4,7 @@ local state = require('render-markdown.state')
 local M = {}
 
 ---@private
-M.version = '7.1.12'
+M.version = '7.1.13'
 
 function M.check()
     M.start('version')