fix: left padding / margin for code blocks indented with tabs

## Details

Issue: #230

When adding inline spaces for padding or margin in code blocks tabs
would cause the spacing to not work. For example if a user wants left
padding of 2 but has tabstop set to 4 the 2 spaces added would be ignored
since they did not occupy enough space to shift the text.

To fix this when adding spaces to the left first check if the code block
contains any tabs. If it does instead of applying the spacing directly
find the next value that is a multiple of the users tabstop and use that.
From the previous example we would add 4 spaces now instead of 2. A
tabstop of 8 and a padding of 10 would result in 16 spaces.

Author: MeanderingProgrammer

doc/render-markdown.txt

@@ -1,4 +1,4 @@
-*render-markdown.txt*         For 0.10.0         Last change: 2024 November 07
+*render-markdown.txt*         For 0.10.0         Last change: 2024 November 08
 
 ==============================================================================
 Table of Contents                          *render-markdown-table-of-contents*

lua/render-markdown/core/context.lua

@@ -91,6 +91,11 @@ function Context:add_checkbox(node, checkbox)
     self.checkboxes[node.start_row] = checkbox
 end
 
+---@return integer
+function Context:tab_size()
+    return util.get('buf', self.buf, 'tabstop') --[[@as integer]]
+end
+
 ---@param node? render.md.Node
 ---@return integer
 function Context:width(node)

lua/render-markdown/health.lua

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

lua/render-markdown/render/code.lua

@@ -46,17 +46,17 @@ function Render:setup()
     end
 
     local max_width = vim.fn.max(widths)
-    local language_padding = self.context:resolve_offset(self.code.language_pad, max_width)
-    local left_padding = self.context:resolve_offset(self.code.left_pad, max_width)
-    local right_padding = self.context:resolve_offset(self.code.right_pad, max_width)
+    local language_padding = self:offset(self.code.language_pad, max_width, self.code.position)
+    local left_padding = self:offset(self.code.left_pad, max_width, 'left')
+    local right_padding = self:offset(self.code.right_pad, max_width, 'right')
     max_width = math.max(widths[1] + language_padding, left_padding + max_width + right_padding, self.code.min_width)
 
     self.data = {
         col = self.node.start_col,
         code_node = code_node,
         language_node = language_node,
         language = (language_node or {}).text,
-        margin = self.context:resolve_offset(self.code.left_margin, max_width),
+        margin = self:offset(self.code.left_margin, max_width, 'left'),
         language_padding = language_padding,
         padding = left_padding,
         max_width = max_width,
@@ -67,6 +67,24 @@ function Render:setup()
     return true
 end
 
+---@private
+---@param offset integer
+---@param width integer
+---@param position render.md.code.Position
+---@return integer
+function Render:offset(offset, width, position)
+    if offset <= 0 then
+        return 0
+    end
+    local result = self.context:resolve_offset(offset, width)
+    if position == 'left' and self.node.text:find('\t') ~= nil then
+        local tab_size = self.context:tab_size()
+        -- Rounds to the next multiple of tab_size
+        result = math.ceil(result / tab_size) * tab_size
+    end
+    return result
+end
+
 function Render:render()
     local disabled_language = self.code.disable_background
     if type(disabled_language) == 'table' then

tests/code_spec.lua

@@ -83,49 +83,53 @@ describe('code.md', function()
 
         vim.list_extend(expected, util.heading(row:get(), 1))
 
-        table.insert(expected, util.code_language(row:increment(2), 0, 'rust', 34))
+        local width_1 = 34
+        table.insert(expected, util.code_language(row:increment(2), 0, 'rust', width_1))
         for _ = 1, 3 do
             vim.list_extend(expected, {
                 padding(row:increment(), 0, 0, 2, 0),
-                util.code_hide(row:get(), 0, 34),
+                util.code_hide(row:get(), 0, width_1),
                 util.code_row(row:get(), 0),
             })
         end
-        table.insert(expected, util.code_border(row:increment(), 0, false, 34))
+        table.insert(expected, util.code_border(row:increment(), 0, false, width_1))
 
+        local width_2 = 20
         vim.list_extend(expected, {
             util.bullet(row:increment(2), 0, 1),
-            util.code_language(row:increment(2), 2, 'lua', 20),
+            util.code_language(row:increment(2), 2, 'lua', width_2),
         })
         for _ = 1, 2 do
             vim.list_extend(expected, {
                 padding(row:increment(), 2, 0, 2, 1000),
-                util.code_hide(row:get(), 2, 20),
+                util.code_hide(row:get(), 2, width_2),
                 util.code_row(row:get(), 2),
             })
         end
-        table.insert(expected, util.code_border(row:increment(), 2, false, 20))
+        table.insert(expected, util.code_border(row:increment(), 2, false, width_2))
 
+        local width_3 = 20
         vim.list_extend(expected, {
             util.bullet(row:increment(2), 0, 1),
-            util.code_language(row:increment(2), 2, 'lua', 20),
+            util.code_language(row:increment(2), 2, 'lua', width_3),
         })
         for _, col in ipairs({ 2, 0, 2 }) do
             vim.list_extend(expected, {
                 padding(row:increment(), col, 2 - col, 2, 1000),
-                util.code_hide(row:get(), col, 20),
+                util.code_hide(row:get(), col, width_3),
                 util.code_row(row:get(), col),
             })
         end
-        table.insert(expected, util.code_border(row:increment(), 2, false, 20))
+        table.insert(expected, util.code_border(row:increment(), 2, false, width_3))
 
+        local width_4 = (2 * vim.opt.tabstop:get()) + 24
         vim.list_extend(expected, {
             util.bullet(row:increment(2), 0, 1),
-            util.code_border(row:increment(2), 0, true, 26),
-            padding(row:increment(), 0, 0, 2, 0),
-            util.code_hide(row:get(), 0, 26),
+            util.code_border(row:increment(2), 0, true, width_4),
+            padding(row:increment(), 0, 0, vim.opt.tabstop:get(), 0),
+            util.code_hide(row:get(), 0, width_4),
             util.code_row(row:get(), 0),
-            util.code_border(row:increment(), 0, false, 26),
+            util.code_border(row:increment(), 0, false, width_4),
         })
 
         local actual = util.get_actual_marks()

tests/data/code.md

@@ -24,5 +24,5 @@ fn main() {
 - No language
 
 ```
-print('Hello, World!')
+	print('Hello, World!')
 ```