feat: roll own type validation, removes reliance on vim.validate

## Details

With the custom validator script we already had most things in place to
remove the underlying usage of vim.validate.

The main part of this change is in better handling of nested types and
capturing non table values where tables are expected.

Since vim.validate is changing in future releases of neovim this avoids
any future required changes to support later versions.

Author: MeanderingProgrammer

CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Pre-release
 
+### Features
+
+- disabling background for code now keeps border [#220](https://github.com/MeanderingProgrammer/render-markdown.nvim/issues/220)
+  [bee16b2](https://github.com/MeanderingProgrammer/render-markdown.nvim/commit/bee16b21bf47b64ceda8c9bb281d4b576d329c0f)
+- table support for all conceal levels [3da1bfc](https://github.com/MeanderingProgrammer/render-markdown.nvim/commit/3da1bfc4bd3a13fee57551f0b705ebcf2614d7a2)
+
+### Bug Fixes
+
+- padding & margin for code blocks indented with tabs [#230](https://github.com/MeanderingProgrammer/render-markdown.nvim/issues/230)
+  [d80acb3](https://github.com/MeanderingProgrammer/render-markdown.nvim/commit/d80acb3f4ccc88052f65fa0a26e46c106b328bbe)
+
 ## 7.5.0 (2024-11-04)
 
 ### Features

doc/render-markdown.txt

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

lua/render-markdown/debug/validator.lua

@@ -1,14 +1,18 @@
+---@class render.md.debug.Spec
+---@field message string
+---@field validation fun(value: any): boolean, string?
+
 ---@class render.md.debug.ValidatorSpec
 ---@field private validator render.md.debug.Validator
 ---@field private config? table<string, any>
 ---@field private nilable boolean
 ---@field private path string
----@field private opts table<string, vim.validate.Spec>
+---@field private specs table<string, render.md.debug.Spec>
 local Spec = {}
 Spec.__index = Spec
 
 ---@param validator render.md.debug.Validator
----@param config table<string, any>
+---@param config? table<string, any>
 ---@param nilable boolean
 ---@param key? string|string[]
 ---@param path? string
@@ -19,65 +23,68 @@ function Spec.new(validator, config, nilable, key, path)
     self.config = config
     self.nilable = nilable
     self.path = path or ''
-    self.opts = {}
-    if key ~= nil then
+    self.specs = {}
+    if self.config ~= nil and key ~= nil then
         key = type(key) == 'table' and key or { key }
         self.path = self.path .. '.' .. table.concat(key, '.')
         self.config = vim.tbl_get(self.config, unpack(key))
-        assert(self.config ~= nil or self.nilable)
+        self.config = type(self.config) == 'table' and self.config or nil
     end
     return self
 end
 
----@return string
-function Spec:get_path()
-    return self.path
-end
-
----@return table<string, any>
-function Spec:get_config()
-    return self.config
-end
-
----@param nilable boolean
+---@param keys 'ALL'|string|string[]
 ---@param f fun(spec: render.md.debug.ValidatorSpec)
-function Spec:for_each(nilable, f)
-    for name in pairs(self.config or {}) do
-        local spec = Spec.new(self.validator, self.config, nilable, name, self.path)
-        f(spec)
-        spec:check()
+---@param nilable? boolean
+---@return render.md.debug.ValidatorSpec
+function Spec:nested(keys, f, nilable)
+    if keys == 'ALL' then
+        keys = self.config ~= nil and vim.tbl_keys(self.config) or {}
+    else
+        keys = type(keys) == 'table' and keys or { keys }
     end
+    if nilable == nil then
+        nilable = self.nilable
+    end
+    for _, key in ipairs(keys) do
+        self:type(key, 'table')
+        f(Spec.new(self.validator, self.config, nilable, key, self.path))
+    end
+    return self
 end
 
 ---@param keys string|string[]
----@param types type|type[]
+---@param input_types type|type[]
 ---@return render.md.debug.ValidatorSpec
-function Spec:type(keys, types)
-    return self:add(keys, types, nil)
+function Spec:type(keys, input_types)
+    local types, message = self:handle_types(input_types, '')
+    return self:add(keys, message, function(value)
+        return vim.tbl_contains(types, type(value))
+    end)
 end
 
 ---@param keys string|string[]
 ---@param values string[]
 ---@param input_types? type|type[]
 ---@return render.md.debug.ValidatorSpec
 function Spec:one_of(keys, values, input_types)
-    local types, suffix = self:handle_types(input_types)
-    return self:add(keys, function(v)
-        return vim.tbl_contains(values, v) or vim.tbl_contains(types, type(v))
-    end, 'one of ' .. vim.inspect(values) .. suffix)
+    local types, message = self:handle_types(input_types, 'one of ' .. vim.inspect(values))
+    return self:add(keys, message, function(value)
+        return vim.tbl_contains(values, value) or vim.tbl_contains(types, type(value))
+    end)
 end
 
 ---@param keys string|string[]
 ---@param list_type type
 ---@param input_types? type|type[]
 ---@return render.md.debug.ValidatorSpec
 function Spec:list(keys, list_type, input_types)
-    local types, suffix = self:handle_types(input_types)
-    return self:add(keys, function(v)
-        if vim.tbl_contains(types, type(v)) then
+    local types, message = self:handle_types(input_types, list_type .. ' list')
+    return self:add(keys, message, function(value)
+        if vim.tbl_contains(types, type(value)) then
             return true
-        elseif type(v) == 'table' then
-            for i, item in ipairs(v) do
+        elseif type(value) == 'table' then
+            for i, item in ipairs(value) do
                 if type(item) ~= list_type then
                     return false, string.format('[%d] is %s', i, type(item))
                 end
@@ -86,20 +93,20 @@ function Spec:list(keys, list_type, input_types)
         else
             return false
         end
-    end, list_type .. ' list' .. suffix)
+    end)
 end
 
 ---@param keys string|string[]
 ---@param list_type type
 ---@param input_types? type|type[]
 ---@return render.md.debug.ValidatorSpec
 function Spec:list_or_list_of_list(keys, list_type, input_types)
-    local types, suffix = self:handle_types(input_types)
-    return self:add(keys, function(v)
-        if vim.tbl_contains(types, type(v)) then
+    local types, message = self:handle_types(input_types, list_type .. ' list or list of list')
+    return self:add(keys, message, function(value)
+        if vim.tbl_contains(types, type(value)) then
             return true
-        elseif type(v) == 'table' then
-            for i, item in ipairs(v) do
+        elseif type(value) == 'table' then
+            for i, item in ipairs(value) do
                 if type(item) == 'table' then
                     for j, nested in ipairs(item) do
                         if type(nested) ~= list_type then
@@ -114,22 +121,22 @@ function Spec:list_or_list_of_list(keys, list_type, input_types)
         else
             return false
         end
-    end, list_type .. ' list or list of list' .. suffix)
+    end)
 end
 
 ---@param keys string|string[]
 ---@param values string[]
 ---@param input_types? type|type[]
 ---@return render.md.debug.ValidatorSpec
 function Spec:one_or_list_of(keys, values, input_types)
-    local types, suffix = self:handle_types(input_types)
-    return self:add(keys, function(v)
-        if vim.tbl_contains(types, type(v)) then
+    local types, message = self:handle_types(input_types, 'one or list of ' .. vim.inspect(values))
+    return self:add(keys, message, function(value)
+        if vim.tbl_contains(types, type(value)) then
             return true
-        elseif type(v) == 'string' then
-            return vim.tbl_contains(values, v)
-        elseif type(v) == 'table' then
-            for i, item in ipairs(v) do
+        elseif type(value) == 'string' then
+            return vim.tbl_contains(values, value)
+        elseif type(value) == 'table' then
+            for i, item in ipairs(value) do
                 if not vim.tbl_contains(values, item) then
                     return false, string.format('[%d] is %s', i, item)
                 end
@@ -138,13 +145,14 @@ function Spec:one_or_list_of(keys, values, input_types)
         else
             return false
         end
-    end, 'one or list of ' .. vim.inspect(values) .. suffix)
+    end)
 end
 
 ---@private
 ---@param input_types? type|type[]
+---@param prefix string
 ---@return type[], string
-function Spec:handle_types(input_types)
+function Spec:handle_types(input_types, prefix)
     local types = nil
     if input_types == nil then
         types = {}
@@ -156,33 +164,36 @@ function Spec:handle_types(input_types)
     if self.nilable and not vim.tbl_contains(types, 'nil') then
         table.insert(types, 'nil')
     end
-    return types, #types == 0 and '' or (' or type ' .. vim.inspect(types))
+    local message = prefix
+    if #types > 0 then
+        if #message > 0 then
+            message = message .. ' or '
+        end
+        message = message .. 'type ' .. table.concat(types, ' or ')
+    end
+    return types, message
 end
 
 ---@private
 ---@param keys string|string[]
----@param logic type|type[]|fun(v: any): boolean, any?
----@param message string?
+---@param message string
+---@param validation fun(v: any): boolean, string?
 ---@return render.md.debug.ValidatorSpec
-function Spec:add(keys, logic, message)
+function Spec:add(keys, message, validation)
     if self.config ~= nil then
         keys = type(keys) == 'table' and keys or { keys }
         for _, key in ipairs(keys) do
-            ---@diagnostic disable-next-line: assign-type-mismatch
-            self.opts[key] = { self.config[key], logic, message or self.nilable }
+            self.specs[key] = { message = message, validation = validation }
         end
     end
     return self
 end
 
 function Spec:check()
-    if self.config == nil then
+    if self.config == nil or vim.tbl_count(self.specs) == 0 then
         return
     end
-    if vim.tbl_count(self.opts) == 0 then
-        return
-    end
-    self.validator:check(self.path, self.config, self.opts)
+    self.validator:check(self.path, self.config, self.specs)
 end
 
 ---@class render.md.debug.Validator
@@ -201,24 +212,33 @@ end
 
 Validator.spec = Spec.new
 
----@param suffix string
+---@param path string
 ---@param config table<string, any>
----@param opts table<string, vim.validate.Spec>
-function Validator:check(suffix, config, opts)
-    local path = self.prefix .. suffix
-    local ok, err = pcall(vim.validate, opts)
-    if not ok then
-        table.insert(self.errors, path .. '.' .. err)
+---@param specs table<string, render.md.debug.Spec>
+function Validator:check(path, config, specs)
+    path = self.prefix .. path
+    for key, spec in pairs(specs) do
+        local value = config[key]
+        local ok, info = spec.validation(value)
+        if not ok then
+            local message = string.format('%s.%s: expected %s, got %s', path, key, spec.message, type(value))
+            if info ~= nil then
+                message = message .. string.format(', info: %s', info)
+            end
+            table.insert(self.errors, message)
+        end
     end
     for key, _ in pairs(config) do
-        if opts[key] == nil then
-            table.insert(self.errors, string.format('%s.%s: is not a valid key', path, key))
+        if specs[key] == nil then
+            local message = string.format('%s.%s: is not a valid key', path, key)
+            table.insert(self.errors, message)
         end
     end
 end
 
 ---@return string[]
 function Validator:get_errors()
+    table.sort(self.errors)
     return self.errors
 end
 

lua/render-markdown/health.lua

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