refactor(config): consolidate validation

Author: Jose Alvarez

lua/null-ls/config.lua

@@ -6,29 +6,45 @@ local defaults = {
     debounce = 250,
     keep_alive_interval = 60000, -- 60 seconds,
     save_after_format = true,
-    on_attach = nil,
-    generators = {},
-    filetypes = {},
-    names = {}
+    _generators = {},
+    _filetypes = {},
+    _names = {},
+    _setup = false
 }
 
+local type_overrides = {
+    on_attach = {"function", "nil"},
+    sources = {"table", "nil"}
+}
+
+local wanted_type = function(k)
+    if vim.startswith(k, "_") then return "nil", true end
+
+    local override = type_overrides[k]
+    if type(override) == "string" then return override, true end
+    if type(override) == "table" then
+        return function(a) return vim.tbl_contains(override, type(a)) end,
+               table.concat(override, ", ")
+    end
+
+    return type(defaults[k]), true
+end
+
 local config = vim.deepcopy(defaults)
 
 -- allow plugins to call register multiple times without duplicating sources
 local is_registered = function(name, insert)
     if not name then return false end
+    if vim.tbl_contains(config._names, name) then return true end
 
-    if vim.tbl_contains(config.names, name) then return true end
-
-    if insert then table.insert(config.names, name) end
-
+    if insert then table.insert(config._names, name) end
     return false
 end
 
 local register_filetypes = function(filetypes)
     for _, filetype in pairs(filetypes) do
-        if not vim.tbl_contains(config.filetypes, filetype) then
-            table.insert(config.filetypes, filetype)
+        if not vim.tbl_contains(config._filetypes, filetype) then
+            table.insert(config._filetypes, filetype)
         end
     end
 end
@@ -49,11 +65,11 @@ local register_source = function(source, filetypes)
     local fn, async = generator.fn, generator.async
     validate({fn = {fn, "function"}, async = {async, "boolean", true}})
 
-    if not config.generators[method] then config.generators[method] = {} end
+    if not config._generators[method] then config._generators[method] = {} end
     register_filetypes(filetypes)
 
     generator.filetypes = filetypes
-    table.insert(config.generators[method], generator)
+    table.insert(config._generators[method], generator)
 
     -- plugins that register sources after BufEnter may need to call try_attach() again,
     -- after filetypes have been registered
@@ -79,51 +95,48 @@ local register = function(to_register)
     if is_registered(name, true) then return end
 
     validate({sources = {sources, "table"}, name = {name, "string", true}})
-
     for _, source in pairs(sources) do register_source(source, filetypes) end
 end
 
 local M = {}
 
 M.get = function() return config end
-
 M.reset = function() config = vim.deepcopy(defaults) end
 
 M.is_registered = is_registered
-
 M.register = register
-
-M.reset_sources = function() config.generators = {} end
+M.reset_sources = function() config._generators = {} end
 
 M.generators = function(method)
-    if method then return config.generators[method] end
-    return config.generators
+    return method and config._generators[method] or config._generators
 end
 
-M.setup = function(user_config)
-    local on_attach, debounce, user_sources, save_after_format,
-          keep_alive_interval = user_config.on_attach, user_config.debounce,
-                                user_config.sources,
-                                user_config.save_after_format,
-                                user_config.keep_alive_interval
+local validate_config = function(user_config)
+    local to_validate, validated = {}, {}
 
-    validate({
-        on_attach = {on_attach, "function", true},
-        debounce = {debounce, "number", true},
-        sources = {user_sources, "table", true},
-        save_after_format = {save_after_format, "boolean", true},
-        keep_alive_interval = {keep_alive_interval, "number", true}
-    })
+    local get_wanted = function(config_table)
+        for k in pairs(config_table) do
+            local wanted, optional = wanted_type(k)
+            to_validate[k] = {user_config[k], wanted, optional}
 
-    if on_attach then config.on_attach = on_attach end
-    if debounce then config.debounce = debounce end
-    if save_after_format ~= nil then
-        config.save_after_format = save_after_format
-    end
-    if keep_alive_interval then
-        config.keep_alive_interval = keep_alive_interval
+            validated[k] = user_config[k]
+        end
     end
-    if user_sources then register(user_sources) end
+    get_wanted(config)
+    get_wanted(type_overrides)
+
+    validate(to_validate)
+    return validated
+end
+
+M.setup = function(user_config)
+    if config._setup then return end
+
+    local validated = validate_config(user_config)
+    config = vim.tbl_extend("force", config, validated)
+
+    if config.sources then register(config.sources) end
+    config._setup = true
 end
 
 return M

test/spec/config_spec.lua

@@ -42,7 +42,7 @@ describe("config", function()
 
             assert.equals(vim.tbl_count(generators), 1)
             assert.equals(vim.tbl_count(generators[mock_source.method]), 1)
-            assert.equals(vim.tbl_count(c.get().filetypes), 2)
+            assert.equals(vim.tbl_count(c.get()._filetypes), 2)
         end)
 
         it("should register additional generators for same method", function()
@@ -53,7 +53,7 @@ describe("config", function()
 
             assert.equals(vim.tbl_count(generators), 1)
             assert.equals(vim.tbl_count(generators[mock_source.method]), 2)
-            assert.equals(vim.tbl_count(c.get().filetypes), 2)
+            assert.equals(vim.tbl_count(c.get()._filetypes), 2)
         end)
 
         it("should call autocommands trigger method after registration",
@@ -71,7 +71,7 @@ describe("config", function()
 
             assert.equals(vim.tbl_count(generators), 1)
             assert.equals(vim.tbl_count(generators[mock_source.method]), 2)
-            assert.equals(vim.tbl_count(c.get().filetypes), 2)
+            assert.equals(vim.tbl_count(c.get()._filetypes), 2)
         end)
 
         it("should register multiple sources with shared configuration",
@@ -85,7 +85,7 @@ describe("config", function()
 
             assert.equals(vim.tbl_count(generators), 1)
             assert.equals(vim.tbl_count(generators[mock_source.method]), 2)
-            assert.equals(vim.tbl_count(c.get().filetypes), 1)
+            assert.equals(vim.tbl_count(c.get()._filetypes), 1)
         end)
 
         it("should only register sources once when name is specified",
@@ -107,7 +107,7 @@ describe("config", function()
     end)
 
     describe("reset_sources", function()
-        it("should reset sources", function()
+        it("should reset sources only", function()
             c.setup({debounce = 500, sources = {mock_source}})
 
             c.reset_sources()
@@ -135,7 +135,32 @@ describe("config", function()
     end)
 
     describe("setup", function()
-        it("should set on_attach", function()
+        it("should set simple config value", function()
+            local debounce = 999
+
+            c.setup({debounce = debounce})
+
+            assert.equals(c.get().debounce, debounce)
+        end)
+
+        it("should only setup config once", function()
+            c.setup({debounce = 999})
+
+            c.setup({debounce = 1})
+
+            assert.equals(c.get().debounce, 999)
+        end)
+
+        it("should throw if simple config type does not match", function()
+            local debounce = "999"
+
+            local ok, err = pcall(c.setup, {debounce = debounce})
+
+            assert.equals(ok, false)
+            assert.matches("expected number", err)
+        end)
+
+        it("should set override config value", function()
             local on_attach = stub.new()
             local _on_attach = function() on_attach() end
 
@@ -145,12 +170,22 @@ describe("config", function()
             assert.stub(on_attach).was_called()
         end)
 
-        it("should set debounce", function()
-            local debounce = 999
+        it("should throw if override config type does not match", function()
+            local on_attach = {"my function"}
 
-            c.setup({debounce = debounce})
+            local ok, err = pcall(c.setup, {on_attach = on_attach})
 
-            assert.equals(c.get().debounce, debounce)
+            assert.equals(ok, false)
+            assert.matches("expected function, nil", err)
+        end)
+
+        it("should throw if config value is private", function()
+            local _names = {"my-integration"}
+
+            local ok, err = pcall(c.setup, {_names = _names})
+
+            assert.equals(ok, false)
+            assert.matches("expected nil", err)
         end)
 
         it("should register sources", function()
@@ -160,7 +195,7 @@ describe("config", function()
 
             assert.equals(vim.tbl_count(generators), 1)
             assert.equals(vim.tbl_count(generators[mock_source.method]), 1)
-            assert.equals(vim.tbl_count(c.get().filetypes), 2)
+            assert.equals(vim.tbl_count(c.get()._filetypes), 2)
         end)
     end)
 end)