feat: more notify() messages when auto installing servers (#131)

lua/mason-lspconfig/ensure_installed.lua

@@ -25,10 +25,7 @@ return function()
                 ---@param pkg Package
                 function(pkg)
                     if not pkg:is_installed() then
-                        notify(("[mason-lspconfig.nvim] installing %s"):format(server_name))
-                        pkg:install {
-                            version = version,
-                        }
+                        require("mason-lspconfig.install").install(pkg, version)
                     end
                 end
             )

lua/mason-lspconfig/install.lua

@@ -0,0 +1,29 @@
+local notify = require "mason-core.notify"
+local server_mapping = require "mason-lspconfig.mappings.server"
+
+local M = {}
+
+---@param pkg Package
+---@param version string?
+---@return InstallHandle
+function M.install(pkg, version)
+    local lspconfig_name = server_mapping.package_to_lspconfig[pkg.name]
+    notify(("[mason-lspconfig.nvim] installing %s"):format(lspconfig_name))
+    return pkg:install({ version = version }):once(
+        "closed",
+        vim.schedule_wrap(function()
+            if pkg:is_installed() then
+                notify(("[mason-lspconfig.nvim] %s was successfully installed"):format(lspconfig_name))
+            else
+                notify(
+                    ("[mason-lspconfig.nvim] failed to install %s. Installation logs are available in :Mason and :MasonLog"):format(
+                        lspconfig_name
+                    ),
+                    vim.log.levels.ERROR
+                )
+            end
+        end)
+    )
+end
+
+return M

lua/mason-lspconfig/lspconfig_hook.lua

@@ -2,7 +2,6 @@ local log = require "mason-core.log"
 local _ = require "mason-core.functional"
 local path = require "mason-core.path"
 local platform = require "mason-core.platform"
-local notify = require "mason-core.notify"
 
 local memoized_set = _.memoize(_.set_of)
 
@@ -74,12 +73,10 @@ return function()
             end
         elseif should_auto_install(config.name) then
             local pkg = registry.get_package(pkg_name)
-            notify(("[mason-lspconfig.nvim] automatically installing %s"):format(pkg.name))
-            pkg:install():once(
+            require("mason-lspconfig.install").install(pkg):once(
                 "closed",
                 vim.schedule_wrap(function()
                     if pkg:is_installed() then
-                        notify(("[mason-lspconfig.nvim] %s was automatically installed"):format(pkg.name))
                         -- reload config
                         require("lspconfig")[config.name].setup(config)
                     end

tests/helpers/lua/fail_dummy.lua

@@ -0,0 +1,12 @@
+local Pkg = require "mason-core.package"
+
+return Pkg.new {
+    name = "fail_dummy",
+    desc = [[This is a dummy package that fails.]],
+    categories = { Pkg.Cat.LSP },
+    languages = { Pkg.Lang.DummyLang },
+    homepage = "https://example.com",
+    install = function()
+        error("fail-dummy doesn't want to be installed", 0)
+    end,
+}

tests/mason-lspconfig/setup_spec.lua

@@ -12,8 +12,10 @@ describe("mason-lspconfig setup", function()
     before_each(function()
         server_mappings.lspconfig_to_package["dummylsp"] = "dummy"
         server_mappings.lspconfig_to_package["dummy2lsp"] = "dummy2"
+        server_mappings.lspconfig_to_package["fail_dummylsp"] = "fail_dummy"
         server_mappings.package_to_lspconfig["dummy"] = "dummylsp"
         server_mappings.package_to_lspconfig["dummy2"] = "dummy2lsp"
+        server_mappings.package_to_lspconfig["fail_dummy"] = "fail_dummylsp"
         filetype_mappings.dummylang = { "dummylsp", "dummy2lsp" }
         require("lspconfig.util").on_setup = nil
         local settings = require "mason-lspconfig.settings"
@@ -46,16 +48,17 @@ describe("mason-lspconfig setup", function()
         "should install servers listed in ensure_installed",
         async_test(function()
             local dummy = registry.get_package "dummy"
+            local fail_dummy = registry.get_package "fail_dummy"
             spy.on(Pkg, "install")
 
-            mason_lspconfig.setup { ensure_installed = { "dummylsp@1.0.0" } }
+            mason_lspconfig.setup { ensure_installed = { "dummylsp@1.0.0", "fail_dummylsp" } }
 
-            assert.spy(Pkg.install).was_called(1)
-            assert.spy(Pkg.install).was_called_with(match.ref(dummy), {
-                version = "1.0.0",
-            })
+            assert.spy(Pkg.install).was_called(2)
+            assert.spy(Pkg.install).was_called_with(match.ref(dummy), { version = "1.0.0" })
+            assert.spy(Pkg.install).was_called_with(match.ref(fail_dummy), { version = nil })
             assert.wait_for(function()
                 assert.is_true(dummy.handle:is_closed())
+                assert.is_true(fail_dummy.handle:is_closed())
             end)
         end)
     )
@@ -64,14 +67,68 @@ describe("mason-lspconfig setup", function()
         "should notify when installing servers listed in ensure_installed",
         async_test(function()
             spy.on(vim, "notify")
+
+            mason_lspconfig.setup { ensure_installed = { "dummylsp", "fail_dummylsp" } }
+
+            assert
+                .spy(vim.notify)
+                .was_called_with([[[mason-lspconfig.nvim] installing dummylsp]], vim.log.levels.INFO, { title = "mason.nvim" })
+            assert
+                .spy(vim.notify)
+                .was_called_with([[[mason-lspconfig.nvim] installing fail_dummylsp]], vim.log.levels.INFO, { title = "mason.nvim" })
+
+            assert.wait_for(function()
+                assert.spy(vim.notify).was_called_with(
+                    [[[mason-lspconfig.nvim] dummylsp was successfully installed]],
+                    vim.log.levels.INFO,
+                    { title = "mason.nvim" }
+                )
+                assert.spy(vim.notify).was_called_with(
+                    [[[mason-lspconfig.nvim] failed to install fail_dummylsp. Installation logs are available in :Mason and :MasonLog]],
+                    vim.log.levels.ERROR,
+                    { title = "mason.nvim" }
+                )
+            end)
+        end)
+    )
+
+    it(
+        "should notify when installing servers via automatic installation",
+        async_test(function()
+            local dummy = registry.get_package "dummy"
+            local fail_dummy = registry.get_package "fail_dummy"
             spy.on(Pkg, "install")
+            spy.on(vim, "notify")
+
+            mason_lspconfig.setup { automatic_installation = true }
+            local lspconfig = require "lspconfig"
+            lspconfig.dummylsp.setup {}
+            lspconfig.fail_dummylsp.setup {}
 
-            mason_lspconfig.setup { ensure_installed = { "dummylsp" } }
+            assert.spy(Pkg.install).was_called(2)
+            assert.spy(Pkg.install).was_called_with(match.ref(dummy), {})
+            assert.spy(Pkg.install).was_called_with(match.ref(fail_dummy), {})
 
-            assert.spy(vim.notify).was_called(1)
             assert
                 .spy(vim.notify)
                 .was_called_with([[[mason-lspconfig.nvim] installing dummylsp]], vim.log.levels.INFO, { title = "mason.nvim" })
+            assert
+                .spy(vim.notify)
+                .was_called_with([[[mason-lspconfig.nvim] installing fail_dummylsp]], vim.log.levels.INFO, { title = "mason.nvim" })
+            assert.wait_for(function()
+                assert.is_true(dummy.handle:is_closed())
+                assert.is_true(fail_dummy.handle:is_closed())
+                assert.spy(vim.notify).was_called_with(
+                    [[[mason-lspconfig.nvim] dummylsp was successfully installed]],
+                    vim.log.levels.INFO,
+                    { title = "mason.nvim" }
+                )
+                assert.spy(vim.notify).was_called_with(
+                    [[[mason-lspconfig.nvim] failed to install fail_dummylsp. Installation logs are available in :Mason and :MasonLog]],
+                    vim.log.levels.ERROR,
+                    { title = "mason.nvim" }
+                )
+            end)
         end)
     )
 
@@ -90,8 +147,8 @@ describe("mason-lspconfig setup", function()
             lspconfig.dummy2lsp.setup {}
 
             assert.spy(Pkg.install).was_called(2)
-            assert.spy(Pkg.install).was_called_with(match.ref(dummy))
-            assert.spy(Pkg.install).was_called_with(match.ref(dummy2))
+            assert.spy(Pkg.install).was_called_with(match.ref(dummy), {})
+            assert.spy(Pkg.install).was_called_with(match.ref(dummy2), {})
 
             assert.wait_for(function()
                 assert.is_true(dummy.handle:is_closed())

tests/minimal_init.vim

@@ -19,10 +19,12 @@ lua <<EOF
 local index = require "mason-registry.index"
 index["dummy"] = "dummy_package"
 index["dummy2"] = "dummy2_package"
+index["fail_dummy"] = "fail_dummy"
 
 local configs = require 'lspconfig.configs'
 configs.dummylsp = { default_config = { cmd = { "dummylsp" } } }
 configs.dummy2lsp = { default_config = { cmd = { "dummy2lsp"} } }
+configs.fail_dummylsp = { default_config = { cmd = { "fail_dummylsp"} } }
 
 require("mason").setup {
     install_root_dir = vim.env.INSTALL_ROOT_DIR,