feat: add make_builtin helper and builtin.with() method

Author: Jose Alvarez

lua/null-ls/builtins/diagnostics.lua

@@ -1,90 +1,88 @@
+local h = require("null-ls.helpers")
 local methods = require("null-ls.methods")
-local helpers = require("null-ls.helpers")
 
 local DIAGNOSTICS = methods.internal.DIAGNOSTICS
 
 local M = {}
 
-M.write_good = {
+M.write_good = h.make_builtin({
     method = DIAGNOSTICS,
     filetypes = {"markdown"},
-    generator = helpers.generator_factory(
-        {
-            command = "write-good",
-            args = {"--text=$TEXT", "--parse"},
-            format = "line",
-            check_exit_code = function(code)
-                return code == 0 or code == 255
-            end,
-            on_output = function(line, params)
-                local pos = vim.split(string.match(line, "%d+:%d+"), ":")
-                local row = pos[1]
+    generator_opts = {
+        command = "write-good",
+        args = {"--text=$TEXT", "--parse"},
+        format = "line",
+        check_exit_code = function(code) return code == 0 or code == 255 end,
+        on_output = function(line, params)
+            local pos = vim.split(string.match(line, "%d+:%d+"), ":")
+            local row = pos[1]
 
-                local message = string.match(line, ":([^:]+)$")
+            local message = string.match(line, ":([^:]+)$")
 
-                local col, end_col
-                local issue = string.match(line, "%b\"\"")
-                local issue_line = params.content[tonumber(row)]
-                if issue and issue_line then
-                    local issue_start, issue_end =
-                        string.find(issue_line, string.match(issue, "([^\"]+)"))
-                    if issue_start and issue_end then
-                        col = tonumber(issue_start) - 1
-                        end_col = issue_end
-                    end
+            local col, end_col
+            local issue = string.match(line, "%b\"\"")
+            local issue_line = params.content[tonumber(row)]
+            if issue and issue_line then
+                local issue_start, issue_end =
+                    string.find(issue_line, string.match(issue, "([^\"]+)"))
+                if issue_start and issue_end then
+                    col = tonumber(issue_start) - 1
+                    end_col = issue_end
                 end
-
-                return {
-                    row = row,
-                    col = col,
-                    end_col = end_col,
-                    message = message,
-                    severity = 1,
-                    source = "write-good"
-                }
             end
-        })
-}
 
-M.markdownlint = {
+            return {
+                row = row,
+                col = col,
+                end_col = end_col,
+                message = message,
+                severity = 1,
+                source = "write-good"
+            }
+        end
+    },
+    factory = h.generator_factory
+})
+
+M.markdownlint = h.make_builtin({
     method = DIAGNOSTICS,
     filetypes = {"markdown"},
-    generator = helpers.generator_factory(
-        {
-            command = "markdownlint",
-            args = {"--stdin"},
-            to_stdin = true,
-            to_stderr = true,
-            format = "line",
-            check_exit_code = function(code) return code <= 1 end,
-            on_output = function(line, params)
-                local split = vim.split(line, " ")
-                local rule = split[2]
-                local _, rule_end = string.find(line, rule, nil, true)
-                local message = string.sub(line, rule_end + 2)
+    generator_opts = {
+        command = "markdownlint",
+        args = {"--stdin"},
+        to_stdin = true,
+        to_stderr = true,
+        format = "line",
+        check_exit_code = function(code) return code <= 1 end,
+        on_output = function(line, params)
+            local split = vim.split(line, " ")
+            local rule = split[2]
+            local _, rule_end = string.find(line, rule, nil, true)
+            local message = string.sub(line, rule_end + 2)
 
-                local pos = vim.split(split[1], ":")
-                local row = pos[2]
-                local col = pos[3]
+            local pos = vim.split(split[1], ":")
+            local row = pos[2]
+            local col = pos[3]
 
-                local end_col
-                local issue = string.match(line, "%b[]")
-                if issue then
-                    issue = string.sub(issue, 2, #issue - 1)
-                    local issue_line = params.content[tonumber(row)]
-                    _, end_col = string.find(issue_line, issue, nil, true)
-                end
-
-                return {
-                    row = row,
-                    col = col and col - 1,
-                    end_col = end_col,
-                    message = message,
-                    severity = 1,
-                    source = "markdownlint"
-                }
+            local end_col
+            local issue = string.match(line, "%b[]")
+            if issue then
+                issue = string.sub(issue, 2, #issue - 1)
+                local issue_line = params.content[tonumber(row)]
+                _, end_col = string.find(issue_line, issue, nil, true)
             end
-        })
-}
+
+            return {
+                row = row,
+                col = col and col - 1,
+                end_col = end_col,
+                message = message,
+                severity = 1,
+                source = "markdownlint"
+            }
+        end
+    },
+    factory = h.generator_factory
+})
 
 return M

lua/null-ls/builtins/formatting.lua

@@ -1,61 +1,59 @@
+local h = require("null-ls.helpers")
 local methods = require("null-ls.methods")
-local helpers = require("null-ls.helpers")
 
 local FORMATTING = methods.internal.FORMATTING
 
 local M = {}
-M.lua_format = {
+
+M.lua_format = h.make_builtin({
     method = FORMATTING,
     filetypes = {"lua"},
-    generator = helpers.formatter_factory(
-        {
-            command = "lua-format",
-            args = {"--single-quote-to-double-quote", "-i"},
-            to_stdin = true,
-            timeout = 2500
-        })
-}
+    generator_opts = {
+        command = "lua-format",
+        args = {"--single-quote-to-double-quote", "-i"},
+        to_stdin = true
+    },
+    factory = h.formatter_factory
+})
 
-M.prettier = {
+M.prettier = h.make_builtin({
     method = FORMATTING,
     filetypes = {
         "javascript", "javascriptreact", "typescript", "typescriptreact", "css",
         "html", "json", "yaml", "markdown"
     },
-    generator = helpers.formatter_factory(
-        {
-            command = "prettier",
-            args = {"--stdin-filepath", "$FILENAME"},
-            to_stdin = true
-        })
-}
+    generator_opts = {
+        command = "prettier",
+        args = {"--stdin-filepath", "$FILENAME"},
+        to_stdin = true
+    },
+    factory = h.formatter_factory
+})
 
-M.prettier_d_slim = {
+M.prettier_d_slim = h.make_builtin({
     method = FORMATTING,
     filetypes = {
         "javascript", "javascriptreact", "typescript", "typescriptreact"
     },
-    generator = helpers.formatter_factory(
-        {
-            command = "prettier_d_slim",
-            args = {"--stdin", "--stdin-filepath", "$FILENAME"},
-            to_stdin = true
-        })
-}
+    generator_opts = {
+        command = "prettier_d_slim",
+        args = {"--stdin", "--stdin-filepath", "$FILENAME"},
+        to_stdin = true
+    },
+    factory = h.formatter_factory
+})
 
-M.eslint_d = {
+M.eslint_d = h.make_builtin({
     method = FORMATTING,
     filetypes = {
         "javascript", "javascriptreact", "typescript", "typescriptreact"
     },
-    generator = helpers.formatter_factory(
-        {
-            command = "eslint_d",
-            args = {
-                "--fix-to-stdout", "--stdin", "--stdin-filename", "$FILENAME"
-            },
-            to_stdin = true
-        })
-}
+    generator_opts = {
+        command = "eslint_d",
+        args = {"--fix-to-stdout", "--stdin", "--stdin-filename", "$FILENAME"},
+        to_stdin = true
+    },
+    factory = h.formatter_factory
+})
 
 return M

lua/null-ls/builtins/test.lua

@@ -1,6 +1,6 @@
 local u = require("null-ls.utils")
+local h = require("null-ls.helpers")
 local methods = require("null-ls.methods")
-local helpers = require("null-ls.helpers")
 
 local api = vim.api
 
@@ -64,29 +64,28 @@ M.mock_code_action = {
     filetypes = {"lua"}
 }
 
-M.slow_code_action = {
+M.slow_code_action = h.make_builtin({
     method = methods.internal.CODE_ACTION,
-    generator = helpers.generator_factory(
-        {
-            command = "bash",
-            args = {"./test/scripts/sleep-and-echo.sh"},
-            format = "raw",
-            timeout = 100,
-            on_output = function(params, done)
-                if not params.output then return done() end
+    filetypes = {"lua"},
+    generator_opts = {
+        command = "bash",
+        args = {"./test/scripts/sleep-and-echo.sh"},
+        timeout = 100,
+        on_output = function(params, done)
+            if not params.output then return done() end
 
-                return done({
-                    {
-                        title = "Slow mock action",
-                        action = function()
-                            print("I took too long!")
-                        end
-                    }
-                })
-            end
-        }),
-    filetypes = {"lua"}
-}
+            return done({
+                {
+                    title = "Slow mock action",
+                    action = function()
+                        print("I took too long!")
+                    end
+                }
+            })
+        end
+    },
+    factory = h.generator_factory
+})
 
 M.mock_diagnostics = {
     method = methods.internal.DIAGNOSTICS,

lua/null-ls/helpers.lua

@@ -145,6 +145,34 @@ M.formatter_factory = function(opts)
     return M.generator_factory(opts)
 end
 
+M.make_builtin = function(opts)
+    local method, filetypes, factory, generator_opts = opts.method,
+                                                       opts.filetypes,
+                                                       opts.factory,
+                                                       opts.generator_opts
+
+    local builtin = {
+        method = method,
+        filetypes = filetypes,
+        _opts = generator_opts
+    }
+
+    setmetatable(builtin, {
+        __index = function(tab, key)
+            return key == "generator" and factory(tab._opts) or rawget(tab, key)
+        end
+    })
+
+    builtin.with = function(user_opts)
+        builtin.filetypes = user_opts.filetypes or builtin.filetypes
+        builtin._opts = vim.tbl_extend("force", builtin._opts, user_opts)
+
+        return builtin
+    end
+
+    return builtin
+end
+
 if _G._TEST then
     M._json_output_wrapper = json_output_wrapper
     M._line_output_wrapper = line_output_wrapper

test/spec/helpers_spec.lua

@@ -259,4 +259,60 @@ describe("helpers", function()
             end)
         end)
     end)
+
+    describe("make_builtin", function()
+        local opts = {
+            method = "mockMethod",
+            filetypes = {"lua"},
+            factory = stub.new(),
+            generator_opts = {key = "val", other_key = "other_val"}
+        }
+        local mock_generator = {fn = function() print("I am a generator") end}
+
+        local builtin
+        before_each(function()
+            opts.factory.returns(mock_generator)
+            builtin = helpers.make_builtin(opts)
+        end)
+
+        after_each(function() opts.factory:clear() end)
+
+        it("should return builtin with assigned opts", function()
+            assert.equals(builtin.method, opts.method)
+            assert.equals(builtin.filetypes, opts.filetypes)
+            assert.equals(builtin._opts, opts.generator_opts)
+        end)
+
+        describe("with", function()
+            it("should override filetypes and return", function()
+                local result = builtin.with({filetypes = {"txt"}})
+
+                assert.same(builtin.filetypes, {"txt"})
+                assert.equals(result, builtin)
+            end)
+
+            it("should override values on opts", function()
+                builtin.with({timeout = 5000})
+
+                assert.equals(builtin._opts.timeout, 5000)
+            end)
+        end)
+
+        describe("index metatable", function()
+            it("should call factory function with opts and return", function()
+                local generator = builtin.generator
+
+                assert.stub(opts.factory).was_called_with(builtin._opts)
+                assert.equals(generator, mock_generator)
+            end)
+
+            it("should call factory function with override opts", function()
+                local result = builtin.with({timeout = 5000})
+
+                local _ = result.generator
+
+                assert.equals(opts.factory.calls[1].refs[1].timeout, 5000)
+            end)
+        end)
+    end)
 end)