feat: add wide/multiple char string and nerd font support for chunk

itepechi · itepechi · commit 2232a5599be7 · 2024-10-01T00:46:28.000+09:00
diff --git a/lua/hlchunk/mods/chunk/init.lua b/lua/hlchunk/mods/chunk/init.lua
@@ -78,46 +78,117 @@ function ChunkMod:get_chunk_data(range, virt_text_list, row_list, virt_text_win_
     local start_col = math.max(math.min(beg_blank_len, end_blank_len) - self.meta.shiftwidth, 0)
 
     if beg_blank_len > 0 then
-        local virt_text_len = beg_blank_len - start_col
-        local beg_virt_text = self.conf.chars.left_top
-            .. self.conf.chars.horizontal_line:rep(virt_text_len - 2)
-            .. (virt_text_len > 1 and self.conf.chars.left_arrow or "")
-        local virt_text, virt_text_win_col = chunkHelper.calc(beg_virt_text, start_col, self.meta.leftcol)
-        local char_list = fn.reverse(utf8Split(virt_text))
-        vim.list_extend(virt_text_list, char_list)
+        local virt_text_width = beg_blank_len - start_col
+        local left_top_width = chunkHelper.virtTextStrWidth(self.conf.chars.left_top, self.meta.shiftwidth)
+        local left_arrow_width = chunkHelper.virtTextStrWidth(self.conf.chars.left_arrow, self.meta.shiftwidth)
+        ---@type string
+        local beg_virt_text
+        if left_top_width + left_arrow_width <= virt_text_width then
+            -- ╭─<if () {
+            -- │
+            -- ╭<if () {
+            -- │
+            beg_virt_text = self.conf.chars.left_top
+                .. chunkHelper.repeatToWidth(
+                    self.conf.chars.horizontal_line,
+                    virt_text_width - left_top_width - left_arrow_width,
+                    self.meta.shiftwidth
+                )
+                .. self.conf.chars.left_arrow
+        elseif left_top_width <= virt_text_width then
+            -- ╭─if () {
+            -- │
+            -- ╭if () {
+            -- │
+            beg_virt_text = self.conf.chars.left_top
+                .. chunkHelper.repeatToWidth(
+                    self.conf.chars.horizontal_line,
+                    virt_text_width - left_top_width,
+                    self.meta.shiftwidth
+                )
+        else
+            --  if () {
+            -- │
+            beg_virt_text = string.rep(" ", virt_text_width)
+        end
+        local virt_text, virt_text_win_col =
+            chunkHelper.calc(beg_virt_text, start_col, self.meta.leftcol, self.meta.shiftwidth)
+        local char_list = utf8Split(virt_text)
+        vim.list_extend(virt_text_list, vim.fn.reverse(char_list))
         vim.list_extend(row_list, vim.fn["repeat"]({ range.start }, #char_list))
-        vim.list_extend(virt_text_win_col_list, rangeFromTo(virt_text_win_col + #char_list - 1, virt_text_win_col, -1))
+        vim.list_extend(
+            virt_text_win_col_list,
+            vim.fn.reverse(chunkHelper.getColList(char_list, virt_text_win_col, self.meta.shiftwidth))
+        )
     end
 
-    local mid_char_nums = range.finish - range.start - 1
+    local mid_row_nums = range.finish - range.start - 1
     vim.list_extend(row_list, rangeFromTo((range.start + 1), (range.finish - 1)))
-    vim.list_extend(virt_text_win_col_list, vim.fn["repeat"]({ start_col - self.meta.leftcol }, mid_char_nums))
-    local mid = self.conf.chars.vertical_line:rep(mid_char_nums)
+    vim.list_extend(virt_text_win_col_list, vim.fn["repeat"]({ start_col - self.meta.leftcol }, mid_row_nums))
+    ---@type string[]
     local chars
     if start_col - self.meta.leftcol < 0 then
-        chars = vim.fn["repeat"]({ "" }, mid_char_nums)
+        chars = vim.fn["repeat"]({ "" }, mid_row_nums)
     else
-        chars = utf8Split(mid)
+        chars = vim.fn["repeat"]({ self.conf.chars.vertical_line }, mid_row_nums)
         -- when use click `<<` or `>>` to indent, we should make sure the line would not encounter the indent char
-        for i = 1, mid_char_nums do
-            local char = Pos.get_char_at_pos(Pos(range.bufnr, range.start + i, start_col), self.meta.shiftwidth)
-            if not char:match("%s") and #char ~= 0 then
+        for i = 1, mid_row_nums do
+            local line = cFunc.get_line(range.bufnr, range.start + i)
+            local vertical_line_width =
+                -- here we need to stop virtTextStrWidth at NULL;
+                -- "mid" virtual texts are not separated and they will be terminated on NULL
+                chunkHelper.virtTextStrWidth(self.conf.chars.vertical_line, self.meta.shiftwidth, true)
+            local end_col = start_col + vertical_line_width
+            if not chunkHelper.checkCellsBlank(line, start_col + 1, end_col, self.meta.shiftwidth) then
                 chars[i] = ""
             end
         end
     end
     vim.list_extend(virt_text_list, chars)
 
     if end_blank_len > 0 then
-        local virt_text_len = end_blank_len - start_col
-        local end_virt_text = self.conf.chars.left_bottom
-            .. self.conf.chars.horizontal_line:rep(virt_text_len - 2)
-            .. (virt_text_len > 1 and self.conf.chars.right_arrow or "")
-        local virt_text, virt_text_win_col = chunkHelper.calc(end_virt_text, start_col, self.meta.leftcol)
+        local virt_text_width = end_blank_len - start_col
+        local left_bottom_width = chunkHelper.virtTextStrWidth(self.conf.chars.left_bottom, self.meta.shiftwidth)
+        local right_arrow_width = chunkHelper.virtTextStrWidth(self.conf.chars.right_arrow, self.meta.shiftwidth)
+        ---@type string
+        local end_virt_text
+        if left_bottom_width + right_arrow_width <= virt_text_width then
+            -- │
+            -- ╰─>}
+            -- │
+            -- ╰>}
+            end_virt_text = self.conf.chars.left_bottom
+                .. chunkHelper.repeatToWidth(
+                    self.conf.chars.horizontal_line,
+                    virt_text_width - left_bottom_width - right_arrow_width,
+                    self.meta.shiftwidth
+                )
+                .. self.conf.chars.right_arrow
+        elseif left_bottom_width <= virt_text_width then
+            -- │
+            -- ╰─}
+            -- │
+            -- ╰}
+            end_virt_text = self.conf.chars.left_bottom
+                .. chunkHelper.repeatToWidth(
+                    self.conf.chars.horizontal_line,
+                    virt_text_width - left_bottom_width,
+                    self.meta.shiftwidth
+                )
+        else
+            -- │
+            --  }
+            end_virt_text = string.rep(" ", virt_text_width)
+        end
+        local virt_text, virt_text_win_col =
+            chunkHelper.calc(end_virt_text, start_col, self.meta.leftcol, self.meta.shiftwidth)
         local char_list = utf8Split(virt_text)
         vim.list_extend(virt_text_list, char_list)
         vim.list_extend(row_list, vim.fn["repeat"]({ range.finish }, #char_list))
-        vim.list_extend(virt_text_win_col_list, rangeFromTo(virt_text_win_col, virt_text_win_col + #char_list - 1))
+        vim.list_extend(
+            virt_text_win_col_list,
+            chunkHelper.getColList(char_list, virt_text_win_col, self.meta.shiftwidth)
+        )
     end
 end
 
diff --git a/lua/hlchunk/utils/chunkHelper.lua b/lua/hlchunk/utils/chunkHelper.lua
@@ -100,8 +100,13 @@ function chunkHelper.get_chunk_range(opts)
     end
 end
 
-function chunkHelper.calc(str, col, leftcol)
-    local len = vim.api.nvim_strwidth(str)
+---@param str string
+---@param col integer
+---@param leftcol integer
+---@param shiftwidth integer
+---@return string, integer
+function chunkHelper.calc(str, col, leftcol, shiftwidth)
+    local len = chunkHelper.virtTextStrWidth(str, shiftwidth)
     if col < leftcol then
         local byte_idx = math.min(leftcol - col, len)
         local utf_beg = vim.str_byteindex(str, byte_idx)
@@ -113,6 +118,8 @@ function chunkHelper.calc(str, col, leftcol)
     return str, col
 end
 
+---@param inputstr string
+---@return string[]
 function chunkHelper.utf8Split(inputstr)
     local list = {}
     for uchar in string.gmatch(inputstr, "[^\128-\191][\128-\191]*") do
@@ -133,6 +140,76 @@ function chunkHelper.rangeFromTo(i, j, step)
     return t
 end
 
+---@param char_list table<integer, string>
+---@param leftcol integer
+---@param shiftwidth integer
+---@return integer[]
+function chunkHelper.getColList(char_list, leftcol, shiftwidth)
+    local t = {}
+    local next_col = leftcol
+    for i = 1, #char_list do
+        table.insert(t, next_col)
+        next_col = next_col + chunkHelper.virtTextStrWidth(char_list[i], shiftwidth)
+    end
+    return t
+end
+
+---@param str string
+---@param width integer
+---@param shiftwidth integer
+function chunkHelper.repeatToWidth(str, width, shiftwidth)
+    local str_width = chunkHelper.virtTextStrWidth(str, shiftwidth)
+
+    -- "1" -> "1111"
+    if str_width == 1 then
+        return str:rep(width)
+    end
+
+    -- "12" -> "1212"
+    if width % str_width == 0 then
+        return str:rep(width / str_width)
+    end
+
+    -- "12" -> "12121"
+    -- "１" -> "１１ "
+    -- "⏻ " -> "⏻ ⏻  "
+    local repeatable_len = math.floor(width / str_width)
+    local s = str:rep(repeatable_len)
+    local chars = chunkHelper.utf8Split(str)
+    local current_width = str_width * repeatable_len
+    local i = 1
+    while i <= #chars do
+        local char_width = chunkHelper.virtTextStrWidth(chars[i], shiftwidth)
+        ---assumed to be an out-of-bounds char (like in nerd fonts) followed by a whitespace if true
+        local likely_oob_char =
+            -- single-cell
+            char_width == 1
+            -- followed by a whitespace
+            and chars[i + 1] == " "
+            -- non-ASCII
+            and chars[i]:byte(1) > 0x7F
+        local char = likely_oob_char and chars[i] .. " " or chars[i]
+        local next_width = current_width + (likely_oob_char and 2 or char_width)
+        if next_width < width then
+            s = s .. char
+            current_width = next_width
+        elseif next_width == width then
+            s = s .. char
+            break
+        else
+            s = s .. string.rep(" ", width - current_width)
+            break
+        end
+        if likely_oob_char then
+            -- skip the whitespace part of out-of-bounds char + " "
+            i = i + 2
+        else
+            i = i + 1
+        end
+    end
+    return s
+end
+
 function chunkHelper.shallowCmp(t1, t2)
     if #t1 ~= #t2 then
         return false
@@ -147,4 +224,150 @@ function chunkHelper.shallowCmp(t1, t2)
     return flag
 end
 
+---@param line string
+---@param start_col integer
+---@param end_col integer
+---@param shiftwidth integer
+---@return boolean
+function chunkHelper.checkCellsBlank(line, start_col, end_col, shiftwidth)
+    local current_col = 1
+    local current_byte = 1
+    local current_char = 1
+    while current_byte <= #line and current_col <= end_col do
+        local final_byte = vim.str_byteindex(line, current_char)
+        local char = line:sub(current_byte, final_byte)
+        local b1, b2, b3 = char:byte(1, 3)
+        if char == "" then
+            break
+        end
+        ---@type integer
+        local next_col
+        local next_byte = final_byte + 1
+        local next_char = current_char + 1
+        if char == " " then
+            next_col = current_col + 1
+        elseif char == "\t" then
+            next_col = current_col + shiftwidth
+        elseif b1 <= 0x1F or char == "\127" then
+            -- despite nvim_strwidth returning 0 or 1, control chars are 2 cells wide
+            next_col = current_col + 2
+        elseif b1 <= 0x7F then
+            -- other ASCII chars are single cell wide
+            next_col = current_col + 1
+        else
+            local char_width = vim.api.nvim_strwidth(char)
+            local next_byte_peek = line:byte(final_byte + 1)
+            if char_width == 1 and next_byte_peek == 0x20 then
+                -- the char is assumed to be an out-of-bounds char (like in nerd fonts)
+                -- followed by a whitespace
+                next_col = current_col + 2
+                -- skip the whitespace part of out-of-bounds char + " "
+                next_byte = next_byte + 1
+                next_char = next_char + 1
+            else
+                next_col = current_col + char_width
+            end
+        end
+        -- we're going to match these characters manually
+        -- as we can't use "%s" to check blank cells
+        -- (e.g. "%s" matches to "\v" but it will be printed as ^K)
+        if
+            (current_col >= start_col or next_col - 1 >= start_col)
+            -- Singles
+            --
+            -- Indent characters
+            -- Unicode Scripts Z*
+            -- 0020 - SPACE
+            and char ~= " "
+            --
+            -- Unicode Scripts C*
+            -- 0009 - TAB
+            -- control characters except TAB should be rendered like "^[" or "<200b>"
+            and char ~= "	"
+            --
+            -- Non indent characters
+            -- Unicode Scripts Z*
+            -- 00A0 - NO-BREAK SPACE
+            and char ~= " "
+            --[[
+            -- 1680 - OGHAM SPACE MARK
+            -- usually rendered as "-"
+            -- see https://www.unicode.org/charts/PDF/U1680.pdf
+            and char ~= " "
+            ]]
+            -- 2000..200A - EN QUAD..HAIR SPACE
+            -- " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "
+            and not (b1 == 0xe2 and b2 == 0x80 and b3 >= 0x80 and b3 <= 0x8a)
+            -- 202F - NARROW NO-BREAK SPACE
+            and char ~= " "
+            -- 205F - MEDIUM MATHEMATICAL SPACE
+            and char ~= " "
+            -- 3000 - IDEOGRAPHIC SPACE
+            and char ~= "　"
+            --[[
+            -- 2028 - LINE SEPARATOR
+            -- some fonts lacks this and may render it as "?" or "█"
+            -- as this character is usually treated as a line-break
+            and char ~= " "
+            ]]
+            --[[
+            -- 2029 - PARAGRAPH SEPARATOR
+            -- some fonts lacks this and may render it as "?" or "█"
+            -- as this character is usually treated as a line-break
+            and char ~= " "
+            ]]
+            --
+            -- Others
+            -- 2800 - BRAILLE PATTERN BLANK
+            and char ~= "⠀"
+            --[[
+            -- 3164 - HANGUL FILLER
+            -- technically "blank" but can easily break the rendering
+            and "\227\133\164" -- do not replace this with a literal notation
+            ]]
+            --[[
+            -- FFA0 - HALFWIDTH HANGUL FILLER
+            -- technically "blank" but can easily break the rendering
+            and "\239\190\160" -- do not replace this with a literal notation
+            ]]
+        then
+            return false
+        end
+        current_col = next_col
+        current_byte = next_byte
+        current_char = next_char
+    end
+    return true
+end
+
+---@param str string
+---@param shiftwidth integer
+---@param stop_on_null? boolean
+---@return integer
+function chunkHelper.virtTextStrWidth(str, shiftwidth, stop_on_null)
+    local current_width = 0
+    for _, char in ipairs(chunkHelper.utf8Split(str)) do
+        if char == "\0" then
+            if stop_on_null then
+                return current_width
+            end
+            -- just ignore otherwise
+        elseif char == "\t" then
+            current_width = current_width + shiftwidth
+        else
+            local b1 = char:byte(1)
+            if b1 <= 0x1F or b1 == 0x7F then
+                -- control chars other than NULL and TAB are two cells wide
+                current_width = current_width + 2
+            elseif b1 <= 0x7F then
+                -- other ASCII chars are single cell wide
+                current_width = current_width + 1
+            else
+                current_width = current_width + vim.api.nvim_strwidth(char)
+            end
+        end
+    end
+    return current_width
+end
+
 return chunkHelper
diff --git a/test/features/chunkHelper_spec.lua b/test/features/chunkHelper_spec.lua
