conditionally enable/disable prettier based on .pretierrc existance in root

[psiho]

Vim and Lua are not my forte but I've been banging my head with this for hours. Using condition on formatting service works ok if I start and finish work on a single project in Nvim. However, switching sessions (and projects) require some more code.

First idea that came to my mind was to register Prettier formatting in setup(), and then disable/enable it in on_attach using `utils.root_has_file(".prettierrc")'. Technically, if I open 2 buffers from 2 different projects it would not work, but that is a rare case. 99% of the time I work on a single project. Problem i want to solve is switching between projects.

So I did:
local utils = require("null-ls.utils").make_conditional_utils()
... and ...

	on_attach = function(client)
	      if utils.root_has_file(".prettierrc") then ...etc... etc... etc...
	end

After many tries, I realized root_has_file() keeps looking at the folder I opened vim in. No matter if I switch projects with nvim-tree (and thus also Vim's pwd). On_attch keeps triggering when I switch projects, open buffers, but root_dir stays the same.
I checked the source code and added this to on_attach:
print("---- get_root(): " .. require("null-ls.utils").get_root())
... and yes, switching projects using nvim sessions does not chage anything. Root_dir stays the same for null-ls.

Any ideas how to implement something like this? Point is, some projects use prettier and some dont. Also, I manage projects through Nvim, with sessions or nvim-tree... I don't want to open/exit nvim every time I switch projects.

[jose-elias-alvarez]

This is mentioned in the documentation, but condition will only run once. Your best bet is to use runtime_condition, which does run on each invocation and so can be used to check the current buffer's root directory. Note that in your case, params.root will still reflect the original root, so you'd have to do something like this:

local prettier = null_ls.builtins.formatting.prettier.with({
    runtime_condition = function(params)
        local utils = require("null-ls.utils")
        -- use whatever root markers you want to check - these are the defaults
        local root = utils.root_pattern(".null-ls-root", "Makefile", ".git")(params.bufname)
        return root and utils.path.exists(utils.path.join(root, ".prettierrc"))
    end,
})

[psiho]

I know condition runs only once, and I also know about runtime_condition running every time. I just thought on_attach would be a good compromise in my case. Because, in general, I try to do more than in this simplified case. I do fallbacks like prettier -> eslint -> langserver which is cleaner to do in one place.

I guess, issue here, no matter what method I use is the fact that params.root still reflect the original root. Again, Nvim/lua at this level is new to me, but I'd like to know is this necessary and why is it like that? Because If I switch sessions, and do :LspInfo, my tsserver does run another instance with proper root_directory and attaches it to buffer (and all subsequent buffers in the same root_directory). Similar behavior is with other servers. Only null-ls does not behave this way.

Anyway, problem for me is solved by wrtiting custom find_root function, like the one you posted above. I'm just curious to learn better how this all works.

Btw, my code with some debug prints, before writing custom root_has_file() func is:

ull_ls = require("null-ls")
local utils = require("null-ls.utils").make_conditional_utils()

local M = {}

function M.prettierIsConfigured()
	return utils.root_has_file(
		{
		".prettierrc", ".prettierrc.json", ".prettierrc.yml", ".prettierrc.yaml", ".prettierrc.json5",
		".prettierrc.js", ".prettierrc.cjs", "prettier.config.js", "prettier.config.cjs",
		".prettierrc.toml"
		}
	)
end

function M.eslintIsConfigured()
	return utils.root_has_file(".eslintrc"
end

function M.chooseFormatting()
	if M.prettierIsConfigured() then
		print "enable PRETTIER formatting as pretierrc is found!"
		null_ls.enable("prettier")
		null_ls.disable({ name = "eslint_d", method = null_ls.methods.FORMATTING })
	elseif M.eslintIsConfigured() then
		print "disable PRETTIER formatting as pretierrc NOT found!"
		null_ls.disable("prettier")
		null_ls.enable({ name = "eslint_d", method = null_ls.methods.FORMATTING })
	else
		print("formatting disabled as no eslintrc nor prettierrc found")
		null_ls.disable("prettier")
		null_ls.disable({ name = "eslint_d", method = null_ls.methods.FORMATTING })
	end
end

function M.chooseLinting()
	if M.eslintIsConfigured() then
		print "enable ESLINT linter as .eslintrc is found!"
		null_ls.enable({ name = "eslint_d", method = null_ls.methods.DIAGNOSTICS })
	else
		print "disable ESLINT linter as .eslintrc is NOT found!"
		null_ls.disable({ name = "eslint_d", method = null_ls.methods.DIAGNOSTICS })
	end
end

--general setup
null_ls.setup({
	sources = {
		null_ls.builtins.diagnostics.eslint_d.with({
			diagnostics_format = "[#{c}] #{m} (#{s})",
		}),
		null_ls.builtins.formatting.prettier,
		null_ls.builtins.formatting.eslint_d,
		null_ls.builtins.code_actions.gitsigns
	}
	on_attach = function(client)
		M.chooseFormatting()
		M.chooseLinting()
	end
})

return M

[jose-elias-alvarez]

nvim-lspconfig has a good deal of code meant to handle root directory changes, which (generally) require spawning a new instance of the language server. Since null-ls runs in memory, there's no need to spawn additional instances, and so the same client (with the same root) is reused. It's possible to port the code or add similar logic here, but generally I want to move towards decoupling null-ls from LSP logic where possible and instead push for abstractions that make more sense for null-ls' architecture.

[psiho]

Thx for the info. All clear now. I ended writing a custom function to check root and use in inside on_attach. I complicated a bit to use it for learning, but it seems to work really well now.

[psiho]

If anybody needs it, or just to tell me if I did something stupid (this is my first nvim/load scripting), here is how I did this:

1. created custom get_root() and folder_has_file() as NulLs's utils allways use original root.
2. used those above to check existence of Prettify and Eslint in the root. Then, stored this info to buffer variable. I used buffer var for 2 reasons. First, it serves as cache so recalculation is not needed. Second, it's easier to integrate with other plugins (in my case Lualine where I want to display status)
   All this is done via autocommand which runs on buffer open
3. Created simple autoToggleServices() which enables/disables NullLs services according to Prettier/Eslint detection stored in buffer var
4. Created another autocommand that runs autoToggleServices() on every BufferEnter. So, switching buffers from 2 different projects now works great.
5. And lastly, I added two small icons to my Lualine tabline which indicates Eslint/Prettier status of the currently active buffer. It's really a simple function that just reads buffer variable mentioned above.

My complete NulLs setup is:

local null_ls = require("null-ls")
local utils = require("null-ls.utils")

-- utils
local folder_has_file = function(folder,...)
  local patterns = vim.tbl_flatten({ ... })
  for _, name in ipairs(patterns) do
    if utils.path.exists(utils.path.join(folder, name)) then
      return true
    end
  end
  return false
end

local function prettierIsConfigured(root)
	return folder_has_file(root,
		{
		".prettierrc", ".prettierrc.json", ".prettierrc.yml", ".prettierrc.yaml", ".prettierrc.json5",
		".prettierrc.js", ".prettierrc.cjs", "prettier.config.js", "prettier.config.cjs",
		".prettierrc.toml"
		}
	)
end

local function eslintIsConfigured(root)
	return folder_has_file(root, ".eslintrc")
end

function _G.null_ls_autoToggleServices()
	local status = vim.b.bufferLspInfo
	if not status then return end

	if  status.hasEslint then
		null_ls.enable({ name = "eslint_d", method = null_ls.methods.DIAGNOSTICS })
	else
		null_ls.disable({ name = "eslint_d", method = null_ls.methods.DIAGNOSTICS })
	end

	if status.hasPrettier then
		null_ls.enable("prettier")
		null_ls.disable({ name = "eslint_d", method = null_ls.methods.FORMATTING })
	elseif status.hasEslint then
		null_ls.disable("prettier")
		null_ls.enable({ name = "eslint_d", method = null_ls.methods.FORMATTING })
	else
		null_ls.disable("prettier")
		null_ls.disable({ name = "eslint_d", method = null_ls.methods.FORMATTING })
	end
end


-- global function for vim autocommand
function _G.null_ls_CalculateBufferLspInfo()
	local root = utils.root_pattern(".null-ls-root", "Makefile", ".git")(vim.fn.expand('%:p'))
	if not root then return false end
	return {
		hasPrettier = prettierIsConfigured(root),
		hasEslint = eslintIsConfigured(root)
	}
end


-- register autocommand to update info when buffer opened
vim.api.nvim_command('autocmd BufReadPre,FileReadPre * lua vim.b.bufferLspInfo = null_ls_CalculateBufferLspInfo()')
-- register autocommand to toggle services on buffer enter
vim.api.nvim_command('autocmd BufEnter * lua null_ls_autoToggleServices()')


--general setup
null_ls.setup({
	sources = {
		null_ls.builtins.diagnostics.eslint_d.with({
			diagnostics_format = "[#{c}] #{m} (#{s})",
		}),
		null_ls.builtins.formatting.prettier,
		null_ls.builtins.formatting.eslint_d,
		null_ls.builtins.code_actions.gitsigns
	},
	 on_attach = function()
	 	null_ls_autoToggleServices()
	 end
})

and for icons in Lualine config:

local function bufferLspInfo()
  if not vim.b.bufferLspInfo then return "" end
  local eslint = vim.b.bufferLspInfo.hasEslint and " " or ""
  local prettier = vim.b.bufferLspInfo.hasPrettier and " " or ""
  return eslint .. prettier
end