feat: Add alignment indicator icons to tables

## Details

Add configurable alignment_indicator field to pipe_table. The
indicator is positioned in the left, right, or center of every
column with alignment information. The indicator must be exactly
a single display width.

While the change is simple at a high level, to implement it we
needed to really parse through the delimiter row. Previously we
did some very simply gsub replacement on the entire line. But now
we need to compute the width between pipes to accurately measure
what's underneath since cells themselves are free to occupy as
much or as little space as they like.

As a result a parser needed to be added which mostly iterates through
the delimiter row and does a good amount of sanity checking before
doing anything with the table.

This information can likely be used to improve how tables are handled
in the future, for now we just add the indicator. Alignmnet itself
is completely up to the user.

Author: MeanderingProgrammer

README.md

@@ -333,6 +333,8 @@ require('render-markdown').setup({
         --  raw: replaces only the '|' characters in each row, leaving the cells unmodified
         --  padded: raw + cells are padded with inline extmarks to make up for any concealed text
         cell = 'padded',
+        -- Gets placed in delimiter row for each column, position is based on alignmnet
+        alignment_indicator = '━',
         -- Characters used to replace table border
         -- Correspond to top(3), delimiter(3), bottom(3), vertical, & horizontal
         -- stylua: ignore
@@ -614,6 +616,8 @@ require('render-markdown').setup({
         --  raw: replaces only the '|' characters in each row, leaving the cells unmodified
         --  padded: raw + cells are padded with inline extmarks to make up for any concealed text
         cell = 'padded',
+        -- Gets placed in delimiter row for each column, position is based on alignmnet
+        alignment_indicator = '━',
         -- Characters used to replace table border
         -- Correspond to top(3), delimiter(3), bottom(3), vertical, & horizontal
         -- stylua: ignore

demo/list_table.gif

@@ -13,13 +13,12 @@
 
 1. Item 1
 2. Item 2
-3. Item 3
 
 # Table
 
-| `Inline Heading` | *Italic Heading*   |
-| ---------------- | ------------------ |
-| Regular Item     | **Bold Item**      |
-| `Item Inline`    | [Link Item](/test) |
+| `Left` | *Center*      | Right | None |
+|  :---  | :----:        |------:| -----|
+| `Code` | **Bold**      | Plain | Item |
+| Item   | [link](/test) | Item  | Item |
 
 [example]: https://example.com

demo/list_table.md

@@ -374,6 +374,8 @@ Full Default Configuration ~
             --  raw: replaces only the '|' characters in each row, leaving the cells unmodified
             --  padded: raw + cells are padded with inline extmarks to make up for any concealed text
             cell = 'padded',
+            -- Gets placed in delimiter row for each column, position is based on alignmnet
+            alignment_indicator = '━',
             -- Characters used to replace table border
             -- Correspond to top(3), delimiter(3), bottom(3), vertical, & horizontal
             -- stylua: ignore
@@ -660,6 +662,8 @@ TABLES                                          *render-markdown-setup-tables*
             --  raw: replaces only the '|' characters in each row, leaving the cells unmodified
             --  padded: raw + cells are padded with inline extmarks to make up for any concealed text
             cell = 'padded',
+            -- Gets placed in delimiter row for each column, position is based on alignmnet
+            alignment_indicator = '━',
             -- Characters used to replace table border
             -- Correspond to top(3), delimiter(3), bottom(3), vertical, & horizontal
             -- stylua: ignore

doc/render-markdown.txt

@@ -3,6 +3,7 @@ local component = require('render-markdown.component')
 local icons = require('render-markdown.icons')
 local list = require('render-markdown.list')
 local logger = require('render-markdown.logger')
+local pipe_table_parser = require('render-markdown.parser.pipe_table')
 local shared = require('render-markdown.handler.shared')
 local state = require('render-markdown.state')
 local str = require('render-markdown.str')
@@ -506,48 +507,55 @@ function M.render_table(buf, info)
     if not pipe_table.enabled or pipe_table.style == 'none' then
         return {}
     end
-    local marks = {}
+    local parsed_table = pipe_table_parser.parse(buf, info)
+    if parsed_table == nil then
+        return {}
+    end
 
-    local delim = nil
-    local first = nil
-    local last = nil
-    for row_node in info.node:iter_children() do
-        local row = ts.info(row_node, buf)
-        if row.type == 'pipe_table_delimiter_row' then
-            delim = row
-            list.add_mark(marks, M.render_table_delimiter(row))
-        elseif row.type == 'pipe_table_header' then
-            first = row
-            vim.list_extend(marks, M.render_table_row(buf, row, pipe_table.head))
-        elseif row.type == 'pipe_table_row' then
-            if last == nil or row.start_row > last.start_row then
-                last = row
-            end
-            vim.list_extend(marks, M.render_table_row(buf, row, pipe_table.row))
-        else
-            logger.unhandled_type('markdown', 'row', row.type)
-        end
+    local marks = {}
+    vim.list_extend(marks, M.render_table_row(buf, parsed_table.head, pipe_table.head))
+    list.add_mark(marks, M.render_table_delimiter(parsed_table.delim, parsed_table.columns))
+    for _, row in ipairs(parsed_table.rows) do
+        vim.list_extend(marks, M.render_table_row(buf, row, pipe_table.row))
     end
     if pipe_table.style == 'full' then
-        vim.list_extend(marks, M.render_table_full(buf, delim, first, last))
+        vim.list_extend(marks, M.render_table_full(buf, parsed_table))
     end
-
     return marks
 end
 
 ---@private
 ---@param row render.md.NodeInfo
+---@param columns render.md.parsed.TableColumn[]
 ---@return render.md.Mark
-function M.render_table_delimiter(row)
+function M.render_table_delimiter(row, columns)
     local pipe_table = state.config.pipe_table
+    local indicator = pipe_table.alignment_indicator
     local border = pipe_table.border
-    -- Order matters here, in particular handling inner intersections before left & right
-    local delimiter = row.text
-        :gsub(' ', '-')
-        :gsub('%-|%-', border[11] .. border[5] .. border[11])
-        :gsub('|%-', border[4] .. border[11])
-        :gsub('%-|', border[11] .. border[6])
-        :gsub('%-', border[11])
+    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 delimiter = border[4] .. table.concat(sections, border[5]) .. border[6]
     ---@type render.md.Mark
     return {
         conceal = true,
@@ -629,16 +637,11 @@ end
 
 ---@private
 ---@param buf integer
----@param delim? render.md.NodeInfo
----@param first? render.md.NodeInfo
----@param last? render.md.NodeInfo
+---@param parsed_table render.md.parsed.Table
 ---@return render.md.Mark[]
-function M.render_table_full(buf, delim, first, last)
+function M.render_table_full(buf, parsed_table)
     local pipe_table = state.config.pipe_table
     local border = pipe_table.border
-    if delim == nil or first == nil or last == nil then
-        return {}
-    end
 
     ---@param info render.md.NodeInfo
     ---@return integer
@@ -652,18 +655,25 @@ function M.render_table_full(buf, delim, first, last)
         return result
     end
 
+    local first = parsed_table.head
+    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(delim.text)
-    if delim_width ~= width(first) or delim_width ~= width(last) then
+    local delim_width = str.width(parsed_table.delim.text)
+    if delim_width ~= width(parsed_table.head) or delim_width ~= width(last) then
         return {}
     end
 
-    local headings = vim.split(delim.text, '|', { plain = true, trimempty = true })
-    local lengths = vim.tbl_map(function(cell)
-        return border[11]:rep(str.width(cell))
-    end, headings)
+    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 line_above = border[1] .. table.concat(lengths, border[2]) .. border[3]
+    local line_above = border[1] .. table.concat(sections, border[2]) .. border[3]
     ---@type render.md.Mark
     local above_mark = {
         conceal = false,
@@ -675,7 +685,7 @@ function M.render_table_full(buf, delim, first, last)
         },
     }
 
-    local line_below = border[7] .. table.concat(lengths, border[8]) .. border[9]
+    local line_below = border[7] .. table.concat(sections, border[8]) .. border[9]
     ---@type render.md.Mark
     local below_mark = {
         conceal = false,

lua/render-markdown/handler/markdown.lua

@@ -35,6 +35,7 @@ local M = {}
 ---@field public style? 'full'|'normal'|'none'
 ---@field public cell? 'padded'|'raw'|'overlay'
 ---@field public border? string[]
+---@field public alignment_indicator? string
 ---@field public head? string
 ---@field public row? string
 ---@field public filler? string
@@ -360,6 +361,8 @@ M.default_config = {
         --  raw: replaces only the '|' characters in each row, leaving the cells unmodified
         --  padded: raw + cells are padded with inline extmarks to make up for any concealed text
         cell = 'padded',
+        -- Gets placed in delimiter row for each column, position is based on alignmnet
+        alignment_indicator = '━',
         -- Characters used to replace table border
         -- Correspond to top(3), delimiter(3), bottom(3), vertical, & horizontal
         -- stylua: ignore

lua/render-markdown/init.lua

@@ -0,0 +1,109 @@
+local logger = require('render-markdown.logger')
+local ts = require('render-markdown.ts')
+
+---@class render.md.parser.PipeTable
+local M = {}
+
+---@class render.md.parsed.TableColumn
+---@field width integer
+---@field alignment 'left'|'right'|'center'|'default'
+
+---@class render.md.parsed.Table
+---@field head render.md.NodeInfo
+---@field delim render.md.NodeInfo
+---@field columns render.md.parsed.TableColumn[]
+---@field rows render.md.NodeInfo[]
+
+---@param buf integer
+---@param info render.md.NodeInfo
+---@return render.md.parsed.Table?
+function M.parse(buf, info)
+    local head = nil
+    local delim = nil
+    local pipes = {}
+    local cells = {}
+    local rows = {}
+    for row_node in info.node:iter_children() do
+        local row = ts.info(row_node, buf)
+        if row.type == 'pipe_table_header' then
+            head = row
+        elseif row.type == 'pipe_table_delimiter_row' then
+            delim = row
+            for cell_node in row.node:iter_children() do
+                local cell = ts.info(cell_node, buf)
+                if cell.type == '|' then
+                    table.insert(pipes, cell)
+                elseif cell.type == 'pipe_table_delimiter_cell' then
+                    table.insert(cells, cell)
+                else
+                    logger.unhandled_type('markdown', 'delim cell', cell.type)
+                end
+            end
+        elseif row.type == 'pipe_table_row' then
+            table.insert(rows, row)
+        else
+            logger.unhandled_type('markdown', 'row', row.type)
+        end
+    end
+    -- Check for empty heading / delimiter
+    if head == nil or delim == nil then
+        return nil
+    end
+    local columns = M.parse_columns(buf, pipes, cells)
+    -- Check for missing row information
+    if #rows == 0 then
+        return nil
+    end
+    ts.sort_inplace(rows)
+    ---@type render.md.parsed.Table
+    return { head = head, delim = delim, columns = columns, rows = rows }
+end
+
+---@private
+---@param buf integer
+---@param pipes render.md.NodeInfo[]
+---@param cells render.md.NodeInfo[]
+---@return render.md.parsed.TableColumn[]
+function M.parse_columns(buf, pipes, cells)
+    -- Check for missing column information
+    if #pipes == 0 or #cells == 0 then
+        return {}
+    end
+    -- Check for mismatch in column fence posts
+    if #pipes ~= #cells + 1 then
+        return {}
+    end
+    ts.sort_inplace(pipes)
+    ts.sort_inplace(cells)
+    local columns = {}
+    for i = 1, #cells do
+        local width = pipes[i + 1].start_col - pipes[i].end_col
+        if width < 0 then
+            return {}
+        end
+        ---@type render.md.parsed.TableColumn
+        local column = { width = width, alignment = M.parse_alignment(buf, cells[i]) }
+        table.insert(columns, column)
+    end
+    return columns
+end
+
+---@private
+---@param buf integer
+---@param cell render.md.NodeInfo
+---@return 'left'|'right'|'center'|'default'
+function M.parse_alignment(buf, cell)
+    local align_left = ts.child(buf, cell, 'pipe_table_align_left') ~= nil
+    local align_right = ts.child(buf, cell, 'pipe_table_align_right') ~= nil
+    if align_left and align_right then
+        return 'center'
+    elseif align_left then
+        return 'left'
+    elseif align_right then
+        return 'right'
+    else
+        return 'default'
+    end
+end
+
+return M

lua/render-markdown/parser/pipe_table.lua

@@ -201,6 +201,7 @@ function state.validate()
         style = one_of(pipe_table.style, { 'full', 'normal', 'none' }),
         cell = one_of(pipe_table.cell, { 'padded', 'raw', 'overlay' }),
         border = string_array(pipe_table.border),
+        alignment_indicator = { pipe_table.alignment_indicator, 'string' },
         head = { pipe_table.head, 'string' },
         row = { pipe_table.row, 'string' },
         filler = { pipe_table.filler, 'string' },

lua/render-markdown/state.lua

@@ -37,6 +37,17 @@ function M.info(node, source)
     }
 end
 
+---@param infos render.md.NodeInfo[]
+function M.sort_inplace(infos)
+    table.sort(infos, function(info1, info2)
+        if info1.start_row ~= info2.start_row then
+            return info1.start_row < info2.start_row
+        else
+            return info1.start_col < info2.start_col
+        end
+    end)
+end
+
 ---Walk through parent nodes, count the number of target nodes
 ---@param info render.md.NodeInfo
 ---@param target string
@@ -71,12 +82,12 @@ end
 ---@param buf integer
 ---@param info render.md.NodeInfo
 ---@param target_type string
----@param target_row integer
+---@param target_row? integer
 ---@return render.md.NodeInfo?
 function M.child(buf, info, target_type, target_row)
     for child in info.node:iter_children() do
         if child:type() == target_type then
-            if child:range() == target_row then
+            if target_row == nil or child:range() == target_row then
                 return M.info(child, buf)
             end
         end

lua/render-markdown/ts.lua

@@ -20,6 +20,7 @@
 ---@field public style 'full'|'normal'|'none'
 ---@field public cell 'padded'|'raw'|'overlay'
 ---@field public border string[]
+---@field public alignment_indicator string
 ---@field public head string
 ---@field public row string
 ---@field public filler string