feat: Support disabling background for all languages but keep borders

## Details

Request: #220

This allows the existing `code.disable_background` option to now be a
boolean in addition to a list of languages. Booleans apply the same
behavior for all languages so when set to `true` all languages will have
their backgrounds disabled.

This does alter the behavior of a disabled background, now borders
above and below the code block will continue to be rendered.

If anyone wants to disable the border as well as the background I can
add another flag for that. Decoupling these 2 concepts matches how we
handle headings as well.

Other changes:

- Window options are now set for all windows attached to the buffer
- Adds `padding_text` method to Base to share common pattern
- Removes most usage of window width, replace with number of columns

Author: MeanderingProgrammer

README.md

@@ -306,6 +306,8 @@ require('render-markdown').setup({
         language_name = true,
         -- A list of language names for which background highlighting will be disabled
         -- Likely because that language has background highlights itself
+        -- Or a boolean to make behavior apply to all languages
+        -- Borders above & below blocks will continue to be rendered
         disable_background = { 'diff' },
         -- Width of the code block background:
         --  block: width of the code block
@@ -732,6 +734,8 @@ require('render-markdown').setup({
         language_name = true,
         -- A list of language names for which background highlighting will be disabled
         -- Likely because that language has background highlights itself
+        -- Or a boolean to make behavior apply to all languages
+        -- Borders above & below blocks will continue to be rendered
         disable_background = { 'diff' },
         -- Width of the code block background:
         --  block: width of the code block

doc/render-markdown.txt

@@ -1,4 +1,4 @@
-*render-markdown.txt*         For 0.10.0         Last change: 2024 November 05
+*render-markdown.txt*         For 0.10.0         Last change: 2024 November 07
 
 ==============================================================================
 Table of Contents                          *render-markdown-table-of-contents*
@@ -353,6 +353,8 @@ Default Configuration ~
             language_name = true,
             -- A list of language names for which background highlighting will be disabled
             -- Likely because that language has background highlights itself
+            -- Or a boolean to make behavior apply to all languages
+            -- Borders above & below blocks will continue to be rendered
             disable_background = { 'diff' },
             -- Width of the code block background:
             --  block: width of the code block
@@ -773,6 +775,8 @@ Code Block Configuration ~
             language_name = true,
             -- A list of language names for which background highlighting will be disabled
             -- Likely because that language has background highlights itself
+            -- Or a boolean to make behavior apply to all languages
+            -- Borders above & below blocks will continue to be rendered
             disable_background = { 'diff' },
             -- Width of the code block background:
             --  block: width of the code block

lua/render-markdown/core/context.lua

@@ -29,9 +29,9 @@ function Context.new(buf, win, mode, offset)
     self.win = win
 
     local ranges = { Context.compute_range(self.buf, self.win, offset) }
-    for _, buf_win in ipairs(vim.fn.win_findbuf(buf)) do
-        if buf_win ~= self.win then
-            table.insert(ranges, Context.compute_range(self.buf, buf_win, offset))
+    for _, window in ipairs(util.windows(buf)) do
+        if window ~= self.win then
+            table.insert(ranges, Context.compute_range(self.buf, window, offset))
         end
     end
     self.ranges = Range.coalesce(ranges)
@@ -139,6 +139,7 @@ function Context:resolve_offset(offset, width)
     end
 end
 
+---@private
 ---@return integer
 function Context:get_width()
     if self.window_width == nil then

lua/render-markdown/core/ui.lua

@@ -112,8 +112,10 @@ function M.run_update(buf, win, parse)
     local next_state = M.next_state(config, win, mode)
 
     log.buf('info', 'state', buf, next_state)
-    for name, value in pairs(config.win_options) do
-        util.set('win', win, name, value[next_state])
+    for _, window in ipairs(util.windows(buf)) do
+        for name, value in pairs(config.win_options) do
+            util.set('win', window, name, value[next_state])
+        end
     end
 
     if next_state == 'rendered' then

lua/render-markdown/core/util.lua

@@ -46,6 +46,12 @@ function M.mode()
     return vim.fn.mode(true)
 end
 
+---@param buf integer
+---@return integer[]
+function M.windows(buf)
+    return vim.fn.win_findbuf(buf)
+end
+
 ---@param buf integer
 ---@param win integer
 ---@return integer?

lua/render-markdown/health.lua

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

lua/render-markdown/init.lua

@@ -134,7 +134,7 @@ local M = {}
 ---@field public position? render.md.code.Position
 ---@field public language_pad? number
 ---@field public language_name? boolean
----@field public disable_background? string[]
+---@field public disable_background? string[]|boolean
 ---@field public width? render.md.code.Width
 ---@field public left_margin? number
 ---@field public left_pad? number
@@ -419,6 +419,8 @@ M.default_config = {
         language_name = true,
         -- A list of language names for which background highlighting will be disabled
         -- Likely because that language has background highlights itself
+        -- Or a boolean to make behavior apply to all languages
+        -- Borders above & below blocks will continue to be rendered
         disable_background = { 'diff' },
         -- Width of the code block background:
         --  block: width of the code block

lua/render-markdown/manager.lua

@@ -71,8 +71,8 @@ function M.attach(buf)
             if not state.enabled then
                 return
             end
-            local win, wins = util.current('win'), vim.fn.win_findbuf(buf)
-            win = vim.tbl_contains(wins, win) and win or wins[1]
+            local win, windows = util.current('win'), util.windows(buf)
+            win = vim.tbl_contains(windows, win) and win or windows[1]
             local event = args.event
             ui.update(buf, win, event, vim.tbl_contains(change_events, event))
         end,

lua/render-markdown/render/base.lua

@@ -83,7 +83,7 @@ end
 function Base:indent_virt_line(line, level)
     local amount = self:indent(level)
     if amount > 0 then
-        table.insert(line, 1, { Str.pad(amount), self.config.padding.highlight })
+        table.insert(line, 1, self:padding_text(amount))
     end
     return line
 end
@@ -109,4 +109,12 @@ function Base:indent(level)
     return indent.per_level * level
 end
 
+---@protected
+---@param width integer
+---@param highlight? string
+---@return { [1]: string, [2]: string }
+function Base:padding_text(width, highlight)
+    return { Str.pad(width), highlight or self.config.padding.highlight }
+end
+
 return Base

lua/render-markdown/render/code.lua

@@ -6,8 +6,6 @@ local colors = require('render-markdown.colors')
 
 ---@class render.md.data.Code
 ---@field col integer
----@field start_row integer
----@field end_row integer
 ---@field code_node? render.md.Node
 ---@field language_node? render.md.Node
 ---@field language? string
@@ -55,8 +53,6 @@ function Render:setup()
 
     self.data = {
         col = self.node.start_col,
-        start_row = self.node.start_row,
-        end_row = self.node.end_row,
         code_node = code_node,
         language_node = language_node,
         language = (language_node or {}).text,
@@ -72,20 +68,23 @@ function Render:setup()
 end
 
 function Render:render()
-    local disabled_language = vim.tbl_contains(self.code.disable_background, self.data.language)
-    local add_background = vim.tbl_contains({ 'normal', 'full' }, self.code.style) and not disabled_language
+    local disabled_language = self.code.disable_background
+    if type(disabled_language) == 'table' then
+        disabled_language = vim.tbl_contains(disabled_language, self.data.language)
+    end
+    local background = vim.tbl_contains({ 'normal', 'full' }, self.code.style) and not disabled_language
 
-    local icon_added = self:language(add_background)
-    if add_background then
-        self:background(icon_added)
+    local icon = self:language()
+    self:border(icon)
+    if background then
+        self:background(self.node.start_row + 1, self.node.end_row - 2)
     end
-    self:left_pad(add_background, icon_added)
+    self:left_pad(background)
 end
 
 ---@private
----@param add_background boolean
 ---@return boolean
-function Render:language(add_background)
+function Render:language()
     if not vim.tbl_contains({ 'language', 'full' }, self.code.style) then
         return false
     end
@@ -103,11 +102,8 @@ function Render:language(add_background)
     if self.code.sign then
         self:sign(icon, icon_highlight)
     end
-    local highlight = { icon_highlight }
-    if add_background then
-        table.insert(highlight, self.code.highlight)
-    end
     local icon_text = icon .. ' '
+    local highlight = { icon_highlight, self.code.highlight }
     if self.code.position == 'left' then
         if self.code.language_name and self.context:hidden(node) then
             -- Code blocks will pick up varying amounts of leading white space depending on the
@@ -138,40 +134,38 @@ function Render:language(add_background)
 end
 
 ---@private
----@param icon_added boolean
-function Render:background(icon_added)
-    local width = self.code.width == 'block' and self.data.max_width or self.context:get_width()
-
-    if self.code.border == 'thin' then
-        ---@param row integer
-        ---@param icon string
-        local function add_border(row, icon)
-            local virt_text = {}
-            if self.data.margin > 0 then
-                table.insert(virt_text, { Str.pad(self.data.margin), self.config.padding.highlight })
-            end
-            table.insert(virt_text, { icon:rep(width - self.data.col), colors.bg_to_fg(self.code.highlight) })
+---@param icon boolean
+function Render:border(icon)
+    ---@param row integer
+    ---@param border string
+    ---@param context_hidden boolean
+    local function add_border(row, border, context_hidden)
+        local delim_hidden = self.context:hidden(self.node:child('fenced_code_block_delimiter', row))
+        if self.code.border == 'thin' and context_hidden and delim_hidden then
+            local width = self.code.width == 'block' and self.data.max_width or vim.o.columns
             self.marks:add('code_border', row, self.data.col, {
-                virt_text = virt_text,
+                virt_text = { { border:rep(width - self.data.col), colors.bg_to_fg(self.code.highlight) } },
                 virt_text_pos = 'overlay',
             })
-        end
-        if not icon_added and self.context:hidden(self.data.code_node) and self:delim_hidden(self.data.start_row) then
-            add_border(self.data.start_row, self.code.above)
-            self.data.start_row = self.data.start_row + 1
-        end
-        if self:delim_hidden(self.data.end_row - 1) then
-            add_border(self.data.end_row - 1, self.code.below)
-            self.data.end_row = self.data.end_row - 1
+        else
+            self:background(row, row)
         end
     end
 
+    add_border(self.node.start_row, self.code.above, not icon and self.context:hidden(self.data.code_node))
+    add_border(self.node.end_row - 1, self.code.below, true)
+end
+
+---@private
+---@param start_row integer
+---@param end_row integer
+function Render:background(start_row, end_row)
     local win_col, padding = 0, {}
     if self.code.width == 'block' then
-        win_col = self.data.margin + width + self.data.indent
-        table.insert(padding, { Str.pad(vim.o.columns * 2), self.config.padding.highlight })
+        win_col = self.data.margin + self.data.max_width + self.data.indent
+        table.insert(padding, self:padding_text(vim.o.columns * 2))
     end
-    for row = self.data.start_row, self.data.end_row - 1 do
+    for row = start_row, end_row do
         self.marks:add('code_background', row, self.data.col, {
             end_row = row + 1,
             hl_group = self.code.highlight,
@@ -189,38 +183,30 @@ function Render:background(icon_added)
 end
 
 ---@private
----@param row integer
----@return boolean
-function Render:delim_hidden(row)
-    return self.context:hidden(self.node:child('fenced_code_block_delimiter', row))
-end
-
----@private
----@param add_background boolean
----@param icon_added boolean
-function Render:left_pad(add_background, icon_added)
+---@param background boolean
+function Render:left_pad(background)
     local margin, padding = self.data.margin, self.data.padding
     if (self.data.col == 0 or #self.data.empty_rows == 0) and margin <= 0 and padding <= 0 then
         return
     end
 
-    -- Use low priority to include other marks in padding when code block is at edge
-    local priority = self.data.col == 0 and 0 or nil
-    local fill_text = { Str.pad(self.data.col), self.config.padding.highlight }
-    local margin_text = { Str.pad(margin), self.config.padding.highlight }
-    local background = add_background and self.code.highlight or self.config.padding.highlight
-    local padding_text = { Str.pad(padding), background }
+    -- Use lowest priority (0) to include all other marks in padding when code block is at edge
+    -- Use medium priority (1000) to include border marks while likely avoiding other plugin
+    local priority = self.data.col == 0 and 0 or 1000
+    local fill_text = self:padding_text(self.data.col)
+    local margin_text = self:padding_text(margin)
+    local padding_text = self:padding_text(padding, background and self.code.highlight or nil)
 
-    for row = self.data.start_row, self.data.end_row - 1 do
+    local start_row, end_row = self.node.start_row, (self.node.end_row - 1)
+    for row = start_row, end_row do
         local virt_text = {}
         if self.data.col > 0 and vim.tbl_contains(self.data.empty_rows, row) then
             table.insert(virt_text, fill_text)
         end
         if margin > 0 then
             table.insert(virt_text, margin_text)
         end
-        local skip_padding = row == self.data.start_row and icon_added
-        if not skip_padding and padding > 0 then
+        if padding > 0 and row > start_row and row < end_row then
             table.insert(virt_text, padding_text)
         end
         if #virt_text > 0 then

lua/render-markdown/render/dash.lua

@@ -16,7 +16,7 @@ end
 
 function Render:render()
     local width = self.dash.width
-    width = type(width) == 'number' and width or self.context:get_width()
+    width = type(width) == 'number' and width or vim.o.columns
     local virt_text = { self.dash.icon:rep(width), self.dash.highlight }
 
     local start_row, end_row = self.node.start_row, self.node.end_row - 1

lua/render-markdown/render/heading.lua

@@ -147,7 +147,7 @@ function Render:width(icon_width)
     return {
         margin = self.context:resolve_offset(self.data.left_margin, width),
         padding = left_padding,
-        content = self.data.width == 'block' and width or self.context:get_width(),
+        content = width,
     }
 end
 
@@ -161,7 +161,7 @@ function Render:background(width)
     local win_col, padding = 0, {}
     if self.data.width == 'block' then
         win_col = width.margin + width.content + self:indent(self.data.level)
-        table.insert(padding, { Str.pad(vim.o.columns * 2), self.config.padding.highlight })
+        table.insert(padding, self:padding_text(vim.o.columns * 2))
     end
     for row = self.node.start_row, self.data.end_row - 1 do
         self.marks:add('head_background', row, 0, {
@@ -203,14 +203,15 @@ function Render:border(width)
             if highlight ~= nil then
                 return { icon:rep(size), highlight }
             else
-                return { Str.pad(size), self.config.padding.highlight }
+                return self:padding_text(size)
             end
         end
+        local content_width = self.data.width == 'block' and width.content or vim.o.columns
         return {
             section(width.margin, nil),
             section(width.padding, background),
             section(prefix, foreground),
-            section(width.content - width.padding - prefix, background),
+            section(content_width - width.padding - prefix, background),
         }
     end
 
@@ -253,15 +254,12 @@ end
 ---@param width render.md.width.Heading
 function Render:left_pad(width)
     local virt_text = {}
-    ---@param size integer
-    ---@param highlight? string
-    local function append(size, highlight)
-        if size > 0 then
-            table.insert(virt_text, { Str.pad(size), highlight or self.config.padding.highlight })
-        end
+    if width.margin > 0 then
+        table.insert(virt_text, self:padding_text(width.margin))
+    end
+    if width.padding > 0 then
+        table.insert(virt_text, self:padding_text(width.padding, self.data.background))
     end
-    append(width.margin, nil)
-    append(width.padding, self.data.background)
     if #virt_text > 0 then
         for row = self.node.start_row, self.data.end_row - 1 do
             self.marks:add(false, row, 0, {