feat: handle imperfectly spaced tables with inline padding

## Details

Currently when rendering tables we take any concealed space and fill
that back in with padding. This effectively means tables will look nice
if they are evenly spaced in their raw text form and otherwise any
poorly aligned text will propagate when rendered.

However we can be smarter about how we calculate the padding needed.
Instead of trying to get back to the raw view when rendering we now
instead calculate the maximum width for every column taking into account
concealed text. From their we caclulate the amount of padding needed
from this maximum value instead. This means nicely aligned tables
continue to work in the exact same way as before but tables with all
sorts of random spacing should now also look beautful.

I will likely follow up with respecting text alignment since this should
be easier to do now, woo!

Author: MeanderingProgrammer

README.md

@@ -55,7 +55,8 @@ Plugin to improve viewing Markdown files in Neovim
   - List bullet points: replace with provided icon based on level
   - Checkboxes: replace with provided icon based on whether they are checked
   - Block quotes: replace leading `>` with provided icon
-  - Tables: replace border characters, does NOT automatically align
+  - Tables: replace border characters, handles misaligned tables but does NOT align
+    according to delimiter indicator
   - [Callouts](https://github.com/orgs/community/discussions/16925)
     - Github & Obsidian out of the box, supports user defined as well
   - Custom checkbox states [^1], function similar to `callouts`

benches/medium_table_spec.lua

@@ -4,7 +4,7 @@ local util = require('benches.util')
 
 describe('medium-table.md', function()
     it('default', function()
-        local base_marks = 468
+        local base_marks = 180
         util.less_than(util.setup('temp/medium-table.md'), 105)
         util.num_marks(base_marks)
 

benches/readme_spec.lua

@@ -4,14 +4,14 @@ local util = require('benches.util')
 
 describe('README.md', function()
     it('default', function()
-        local base_marks = 54
+        local base_marks = 45
         util.less_than(util.setup('README.md'), 50)
         util.num_marks(base_marks)
 
         util.less_than(util.move_down(1), 0.5)
         util.num_marks(base_marks + 2)
 
-        util.less_than(util.insert_mode(), 20)
+        util.less_than(util.insert_mode(), 5)
         util.num_marks(base_marks + 2)
     end)
 end)

doc/render-markdown.txt

@@ -1,4 +1,4 @@
-*render-markdown.txt*          For 0.10.0          Last change: 2024 August 09
+*render-markdown.txt*          For 0.10.0          Last change: 2024 August 11
 
 ==============================================================================
 Table of Contents                          *render-markdown-table-of-contents*
@@ -74,7 +74,8 @@ Plugin to improve viewing Markdown files in Neovim
     - List bullet points: replace with provided icon based on level
     - Checkboxes: replace with provided icon based on whether they are checked
     - Block quotes: replace leading `>` with provided icon
-    - Tables: replace border characters, does NOT automatically align
+    - Tables: replace border characters, handles misaligned tables but does NOT align
+        according to delimiter indicator
     - Callouts <https://github.com/orgs/community/discussions/16925>
         - Github & Obsidian out of the box, supports user defined as well
     - Custom checkbox states , function similar to `callouts`

lua/render-markdown/context.lua

@@ -74,6 +74,12 @@ function Context:contains_node(node)
     return top < self.bottom and bottom >= self.top
 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
+end
+
 ---@param root TSNode
 ---@param query vim.treesitter.Query
 ---@param callback fun(capture: string, node: TSNode, metadata: vim.treesitter.query.TSMetadata)

lua/render-markdown/handler/markdown.lua

@@ -519,93 +519,91 @@ function Handler:pipe_table(info)
     if not pipe_table.enabled or pipe_table.style == 'none' then
         return
     end
-    local parsed_table = pipe_table_parser.parse(info)
+    local parsed_table = pipe_table_parser.parse(self.context, info)
     if parsed_table == nil then
         return
     end
 
-    self:table_row(parsed_table.head, pipe_table.head)
-    self:table_delimiter(parsed_table.delim, parsed_table.columns)
+    self:table_delimiter(parsed_table.delim)
     for _, row in ipairs(parsed_table.rows) do
-        self:table_row(row, pipe_table.row)
+        self:table_row(parsed_table.delim, row)
     end
     if pipe_table.style == 'full' then
         self:table_full(parsed_table)
     end
 end
 
 ---@private
----@param row render.md.NodeInfo
----@param columns render.md.parsed.TableColumn[]
-function Handler:table_delimiter(row, columns)
+---@param delim render.md.parsed.table.DelimRow
+function Handler:table_delimiter(delim)
     local pipe_table = self.config.pipe_table
     local indicator = pipe_table.alignment_indicator
     local border = pipe_table.border
-    local sections = vim.tbl_map(
-        ---@param column render.md.parsed.TableColumn
-        ---@return string
-        function(column)
-            -- If column is small there's no good place to put the alignment indicator
-            -- Alignment indicator must be exactly one character wide
-            -- We do not put an indicator for default alignment
-            if column.width < 4 or str.width(indicator) ~= 1 or column.alignment == 'default' then
-                return border[11]:rep(column.width)
-            end
-            -- Handle the various alignmnet possibilities
-            local left = border[11]:rep(math.floor(column.width / 2))
-            local right = border[11]:rep(math.ceil(column.width / 2) - 1)
-            if column.alignment == 'left' then
-                return indicator .. left .. right
-            elseif column.alignment == 'right' then
-                return left .. right .. indicator
-            else
-                return left .. indicator .. right
-            end
-        end,
-        columns
-    )
+    local sections = vim.tbl_map(function(column)
+        -- If column is small there's no good place to put the alignment indicator
+        -- Alignment indicator must be exactly one character wide
+        -- Do not put an indicator for default alignment
+        if column.width < 4 or str.width(indicator) ~= 1 or column.alignment == 'default' then
+            return border[11]:rep(column.width)
+        end
+        -- Handle the various alignmnet possibilities
+        local left = border[11]:rep(math.floor(column.width / 2))
+        local right = border[11]:rep(math.ceil(column.width / 2) - 1)
+        if column.alignment == 'left' then
+            return indicator .. left .. right
+        elseif column.alignment == 'right' then
+            return left .. right .. indicator
+        else
+            return left .. indicator .. right
+        end
+    end, delim.columns)
     local delimiter = border[4] .. table.concat(sections, border[5]) .. border[6]
-    self:add(true, row.start_row, row.start_col, {
-        end_row = row.end_row,
-        end_col = row.end_col,
+    self:add(true, delim.info.start_row, delim.info.start_col, {
+        end_row = delim.info.end_row,
+        end_col = delim.info.end_col,
         virt_text = { { delimiter, pipe_table.head } },
         virt_text_pos = 'overlay',
     })
 end
 
 ---@private
----@param row render.md.NodeInfo
----@param highlight string
-function Handler:table_row(row, highlight)
+---@param delim render.md.parsed.table.DelimRow
+---@param row render.md.parsed.table.Row
+function Handler:table_row(delim, row)
     local pipe_table = self.config.pipe_table
-    if vim.tbl_contains({ 'raw', 'padded' }, pipe_table.cell) then
-        row:for_each_child(function(cell)
-            if cell.type == '|' then
-                self:add(true, cell.start_row, cell.start_col, {
-                    end_row = cell.end_row,
-                    end_col = cell.end_col,
-                    virt_text = { { pipe_table.border[10], highlight } },
-                    virt_text_pos = 'overlay',
+    local highlight = row.info.type == 'pipe_table_header' and pipe_table.head or pipe_table.row
+    if pipe_table.cell == 'padded' then
+        for _, pipe in ipairs(row.pipes) do
+            self:add(true, pipe.start_row, pipe.start_col, {
+                end_row = pipe.end_row,
+                end_col = pipe.end_col,
+                virt_text = { { pipe_table.border[10], highlight } },
+                virt_text_pos = 'overlay',
+            })
+        end
+        for i, column in ipairs(row.columns) do
+            local offset = delim.columns[i].width - column.width
+            if offset > 0 then
+                self:add(true, column.info.start_row, column.info.end_col - 1, {
+                    virt_text = { { str.pad(offset), pipe_table.filler } },
+                    virt_text_pos = 'inline',
                 })
-            elseif cell.type == 'pipe_table_cell' then
-                if pipe_table.cell == 'padded' then
-                    local offset = self:table_visual_offset(cell)
-                    if offset > 0 then
-                        self:add(true, cell.start_row, cell.end_col - 1, {
-                            virt_text = { { str.pad(offset), pipe_table.filler } },
-                            virt_text_pos = 'inline',
-                        })
-                    end
-                end
-            else
-                logger.unhandled_type('markdown', 'cell', cell.type)
             end
-        end)
+        end
+    elseif pipe_table.cell == 'raw' then
+        for _, pipe in ipairs(row.pipes) do
+            self:add(true, pipe.start_row, pipe.start_col, {
+                end_row = pipe.end_row,
+                end_col = pipe.end_col,
+                virt_text = { { pipe_table.border[10], highlight } },
+                virt_text_pos = 'overlay',
+            })
+        end
     elseif pipe_table.cell == 'overlay' then
-        self:add(true, row.start_row, row.start_col, {
-            end_row = row.end_row,
-            end_col = row.end_col,
-            virt_text = { { row.text:gsub('|', pipe_table.border[10]), highlight } },
+        self:add(true, row.info.start_row, row.info.start_col, {
+            end_row = row.info.end_row,
+            end_col = row.info.end_col,
+            virt_text = { { row.info.text:gsub('|', pipe_table.border[10]), highlight } },
             virt_text_pos = 'overlay',
         })
     end
@@ -617,56 +615,53 @@ function Handler:table_full(parsed_table)
     local pipe_table = self.config.pipe_table
     local border = pipe_table.border
 
-    ---@param info render.md.NodeInfo
-    ---@return integer
-    local function width(info)
-        local result = str.width(info.text)
-        if pipe_table.cell == 'raw' then
-            -- For the raw cell style we want the lengths to match after
-            -- concealing & inlined elements
-            result = result - self:table_visual_offset(info)
+    ---@param row render.md.parsed.table.Row
+    ---@param delim render.md.parsed.table.DelimRow
+    ---@return boolean
+    local function width_equal(row, delim)
+        if pipe_table.cell == 'padded' then
+            -- Assume table was padded to match
+            return true
+        elseif pipe_table.cell == 'raw' then
+            -- Want the computed widths to match
+            for i, column in ipairs(row.columns) do
+                if delim.columns[i].width ~= column.width then
+                    return false
+                end
+            end
+            return true
+        elseif pipe_table.cell == 'overlay' then
+            -- Want the underlying text widths to match
+            return str.width(delim.info.text) == str.width(row.info.text)
+        else
+            return false
         end
-        return result
     end
 
-    local first = parsed_table.head
+    local delim = parsed_table.delim
+    local first = parsed_table.rows[1]
     local last = parsed_table.rows[#parsed_table.rows]
-
-    -- Do not need to account for concealed / inlined text on delimiter row
-    local delim_width = str.width(parsed_table.delim.text)
-    if delim_width ~= width(first) or delim_width ~= width(last) then
-        return {}
+    if not width_equal(first, delim) or not width_equal(last, delim) then
+        return
     end
 
-    local sections = vim.tbl_map(
-        ---@param column render.md.parsed.TableColumn
-        ---@return string
-        function(column)
-            return border[11]:rep(column.width)
-        end,
-        parsed_table.columns
-    )
+    local sections = vim.tbl_map(function(column)
+        return border[11]:rep(column.width)
+    end, delim.columns)
 
     local line_above = border[1] .. table.concat(sections, border[2]) .. border[3]
-    self:add(false, first.start_row, first.start_col, {
+    self:add(false, first.info.start_row, first.info.start_col, {
         virt_lines_above = true,
         virt_lines = { { { line_above, pipe_table.head } } },
     })
 
     local line_below = border[7] .. table.concat(sections, border[8]) .. border[9]
-    self:add(false, last.start_row, last.start_col, {
+    self:add(false, last.info.start_row, last.info.start_col, {
         virt_lines_above = false,
         virt_lines = { { { line_below, pipe_table.row } } },
     })
 end
 
----@private
----@param info render.md.NodeInfo
----@return integer
-function Handler:table_visual_offset(info)
-    return self.context:concealed(info) - self.context:link_width(info)
-end
-
 ---@class render.md.handler.Markdown: render.md.Handler
 local M = {}
 

lua/render-markdown/health.lua

@@ -5,7 +5,7 @@ local M = {}
 
 ---@private
 ---@type string
-M.version = '6.0.13'
+M.version = '6.1.1'
 
 function M.check()
     vim.health.start('render-markdown.nvim [version]')