Not reproducible?

[Readf0x]

I recently installed on a new computer, using the exact same flake with the same lockfile, no changes to nixvim configuration, and yet it doesn't work? It seems that it's not sourcing/loading a lot of the custom plugins I have (tender theme, zoxide, easy-align). Anyone know why that might be the case?

[GaetanLepage]

There could be some files in your homedir that could hinder your nixvim config.
Check:

• ~/.config/nvim/
• ~/.local/share/nvim
• ~/.local/state/nvim

If you have nothing important there, try to clear those folders and see if your issue happens again.

[Readf0x]

the issue still occurs.

[Readf0x]

I have found something concerning, the hash of both configs is exactly the same. So it is in fact reproducible, but for some reason the exact same init.lua works on one machine and not the other.

[GaetanLepage]

Are your "custom plugins", built using pkgs.buildVimPlugin or are they loaded from disk ?

[Readf0x]

I suppose "custom" was the wrong word to use here, as they are all plugins from nixpkgs loaded with the extra plugins option.

[GaetanLepage]

Ok, this should not pose any problem.

Could you please provide further details on your configuration, the produced init.lua (nixvim-print-init) and the error message you get?

[Readf0x]

I apologize for the delay, I was away for a while. Here's the produced init.lua

init.lua

-- Nixvim's internal module table
-- Can be used to share code throughout init.lua
local _M = {}

-- Set up globals {{{
do
    local nixvim_globals = { lazygit_floating_window_border_chars = { "", "", "", "", "", "", "", "" } }

    for k, v in pairs(nixvim_globals) do
        vim.g[k] = v
    end
end
-- }}}

-- Set up options {{{
do
    local nixvim_options = { clipboard = "unnamedplus", foldexpr = "nvim_treesitter#foldexpr()", foldmethod = "expr" }

    for k, v in pairs(nixvim_options) do
        vim.opt[k] = v
    end
end
-- }}}

vim.g.mapleader = " "

vim.cmd([[let $BAT_THEME = 'tender'

colorscheme tender

source /nix/store/sczxaivh2jkg0axsvpjd4rrlblrf2jix-vimplugin-vim-easy-align-2024-04-13/autoload/easy_align.vim
source /nix/store/sczxaivh2jkg0axsvpjd4rrlblrf2jix-vimplugin-vim-easy-align-2024-04-13/plugin/easy_align.vim
source /nix/store/azb94ipzcm8z8706qzrcrsdwlgi6vlng-vimplugin-zoxide.vim-2023-10-23/autoload/zoxide.vim
source /nix/store/azb94ipzcm8z8706qzrcrsdwlgi6vlng-vimplugin-zoxide.vim-2023-10-23/plugin/zoxide.vim

set tabstop=2
set shiftwidth=2
set expandtab
set nowrap
set foldlevel=99
set number relativenumber
set signcolumn=yes
set scrolloff=10

hi NormalFloat guibg=#1D1D1D
hi Pmenu guifg=#EEEEEE guibg=#1D1D1D
hi Statement gui=italic cterm=italic
hi @property.jsonc guifg=#73CEF4 ctermfg=81
hi @tag.html guifg=#EEEEEE
hi @punctuation.delimiter.jsdoc guifg=#EEEEEE

set splitbelow
set splitright
]])
local cmp = require("cmp")
cmp.setup({
    mapping = {
        ["<C-Esc>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
                cmp.abort()
            else
                fallback()
            end
        end),
        ["<C-Space>"] = cmp.mapping.complete(),
        ["<C-d>"] = cmp.mapping.scroll_docs(-4),
        ["<C-e>"] = cmp.mapping.close(),
        ["<C-f>"] = cmp.mapping.scroll_docs(4),
        ["<CR>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
                if require("luasnip").expandable() then
                    require("luasnip").expand()
                else
                    cmp.confirm({ select = true })
                end
            else
                fallback()
            end
        end),
        ["<S-Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
                cmp.select_prev_item()
            elseif require("luasnip").locally_jumpable(-1) then
                require("luasnip").jump(-1)
            else
                fallback()
            end
        end, { "i", "s" }),
        ["<Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
                cmp.select_next_item()
            elseif require("luasnip").locally_jumpable(1) then
                require("luasnip").jump(1)
            else
                fallback()
            end
        end, { "i", "s" }),
    },
    preselect = cmp.PreselectMode.None,
    sources = {
        { group_index = 1, name = "calc", priority = 4 },
        { group_index = 1, name = "luasnip", priority = 4 },
        { group_index = 1, name = "nvim_lsp", priority = 2 },
        {
            entry_filter = function()
                if vim.bo.filetype == "zsh" then
                    return true
                else
                    return false
                end
            end,
            group_index = 1,
            name = "zsh",
            priority = 2,
        },
        { group_index = 2, name = "nvim_lsp_document_symbol", priority = 2 },
        { group_index = 2, name = "treesitter", priority = 2 },
        { group_index = 2, name = "fuzzy_buffer", priority = 1 },
    },
})

require("which-key").setup({
    icons = { mappings = false },
    spec = {
        { "<C-g>", group = "Git", mode = { "n", "v" } },
        {
            {
                { "<leader>", group = "Leader" },
                { "<leader>t", group = "Telescope" },
                { "<leader>b", group = "Per buffer" },
            },
            mode = { "n", "v" },
        },
    },
})

require("ts-comments").setup({})

require("nvim-ts-autotag").setup({})

require("treesitter-context").setup({})

vim.opt.runtimepath:prepend(vim.fs.joinpath(vim.fn.stdpath("data"), "site"))
require("nvim-treesitter.configs").setup({
    highlight = { enable = true },
    indent = { enable = true },
    parser_install_dir = vim.fs.joinpath(vim.fn.stdpath("data"), "site"),
})

require("telescope").setup({})

local __telescopeExtensions = { "fzf" }
for i, extension in ipairs(__telescopeExtensions) do
    require("telescope").load_extension(extension)
end

require("mini.ai").setup({ enable = true })

require("mini.icons").setup({ enable = true })

require("mini.pairs").setup({
    markdown = true,
    modes = { command = true, insert = true, terminal = false },
    skip_next = "[=[[%w%%%'%[%\"%.%`%$]]=]",
    skip_ts = '{ "string" }',
    skip_unbalanced = true,
})

require("mini.surround").setup({ enable = true })
MiniIcons.mock_nvim_web_devicons()

require("lualine").setup({
    options = {
        component_separators = { left = "┃", right = "┃" },
        ignore_focus = { "neo-tree", "nvim-tree", "mini-files" },
        section_separators = { left = "", right = "" },
    },
    sections = { lualine_x = { "encoding", "filetype" } },
})

require("gitsigns").setup({})

require("git-conflict").setup({})

-- LSP {{{
do
    local __lspServers = {
        {
            extraOptions = {
                filetypes = {
                    "javascript",
                    "javascriptreact",
                    "javascript.jsx",
                    "typescript",
                    "typescriptreact",
                    "typescript.tsx",
                },
            },
            name = "ts_ls",
        },
        { name = "nil_ls" },
        {
            extraOptions = {
                settings = {
                    json = {
                        schemas = {
                            { fileMatch = { "package.json" }, url = "https://json.schemastore.org/package.json" },
                            { fileMatch = { "tsconfig*.json" }, url = "https://json.schemastore.org/tsconfig.json" },
                            {
                                fileMatch = { ".prettierrc", ".prettierrc.json", "prettier.config.json" },
                                url = "https://json.schemastore.org/prettierrc.json",
                            },
                            {
                                fileMatch = { ".eslintrc", ".eslintrc.json" },
                                url = "https://json.schemastore.org/eslintrc.json",
                            },
                            {
                                fileMatch = { ".babelrc", ".babelrc.json", "babel.config.json" },
                                url = "https://json.schemastore.org/babelrc.json",
                            },
                            { fileMatch = { "lerna.json" }, url = "https://json.schemastore.org/lerna.json" },
                            { fileMatch = { "now.json", "vercel.json" }, url = "https://json.schemastore.org/now.json" },
                            {
                                fileMatch = { ".stylelintrc", ".stylelintrc.json", "stylelint.config.json" },
                                url = "http://json.schemastore.org/stylelintrc.json",
                            },
                        },
                    },
                },
            },
            name = "jsonls",
        },
        { name = "htmx" },
        { name = "html" },
        { name = "gopls" },
        { name = "eslint" },
        { name = "cssls" },
        { name = "bashls" },
        { name = "astro" },
    }
    -- Adding lspOnAttach function to nixvim module lua table so other plugins can hook into it.
    _M.lspOnAttach = function(client, bufnr) end
    local __lspCapabilities = function()
        capabilities = vim.lsp.protocol.make_client_capabilities()

        capabilities = vim.tbl_deep_extend("force", capabilities, require("cmp_nvim_lsp").default_capabilities())

        return capabilities
    end

    local __setup = {
        on_attach = _M.lspOnAttach,
        capabilities = __lspCapabilities(),
    }

    for i, server in ipairs(__lspServers) do
        if type(server) == "string" then
            require("lspconfig")[server].setup(__setup)
        else
            local options = server.extraOptions

            if options == nil then
                options = __setup
            else
                options = vim.tbl_extend("keep", options, __setup)
            end

            require("lspconfig")[server.name].setup(options)
        end
    end
end
-- }}}

require("colorizer").setup({
    filetypes = nil,
    user_default_options = nil,
    buftypes = nil,
})

require("neo-tree").setup({ document_symbols = { custom_kinds = {} } })

require("luasnip").config.setup({})

require("luasnip.loaders.from_vscode").lazy_load({})

require("luasnip.loaders.from_vscode").lazy_load({})

require("inc_rename").setup({})

require("gitlinker").setup({})

-- Set up keybinds {{{
do
    local __nixvim_binds = {
        { action = "cc", key = "C", mode = "n", options = { desc = "Change line" } },
        { action = "<End>", key = "<CR>", mode = "", options = { desc = "End of line" } },
        { action = "zl", key = "<C-l>", mode = { "n", "v" }, options = { desc = "Scroll right single" } },
        { action = "zL", key = "<C-k>", mode = { "n", "v" }, options = { desc = "Scroll right" } },
        { action = "zh", key = "<C-h>", mode = { "n", "v" }, options = { desc = "Scroll left single" } },
        { action = "zH", key = "<C-j>", mode = { "n", "v" }, options = { desc = "Scroll left" } },
        {
            action = function()
                if require("luasnip").choice_active() then
                    require("luasnip").change_choice(1)
                end
            end,
            key = "<C-n>",
            mode = { "i", "s" },
            options = { desc = "Next choice" },
        },
        {
            action = function()
                if require("luasnip").choice_active() then
                    require("luasnip").change_choice(-1)
                end
            end,
            key = "<C-m>",
            mode = { "i", "s" },
            options = { desc = "Prev choice" },
        },
        {
            action = "<cmd>Gitsigns reset_hunk<CR>",
            key = "<C-g>r",
            mode = { "n", "v" },
            options = { desc = "Reset hunk" },
        },
        {
            action = "<cmd>Gitsigns stage_hunk<CR>",
            key = "<C-g>s",
            mode = { "n", "v" },
            options = { desc = "Stage hunk" },
        },
        { action = "<cmd>Gitsigns stage_buffer<CR>", key = "<C-g>S", mode = "n", options = { desc = "Stage buffer" } },
        { action = "<cmd>Gitsigns undo_stage_hunk<CR>", key = "<C-g>u", mode = "n", options = { desc = "Undo stage" } },
        { action = "<cmd>Gitsigns reset_buffer<CR>", key = "<C-g>R", mode = "n", options = { desc = "Reset buffer" } },
        { action = "<cmd>Gitsigns preview_hunk<CR>", key = "<C-g>p", mode = "n", options = { desc = "Preview hunk" } },
        { action = "<cmd>Gitsigns blame_line<CR>", key = "<C-g>b", mode = "n", options = { desc = "Blame line" } },
        { action = "<cmd>Gitsigns diffthis<CR>", key = "<C-g>d", mode = "n", options = { desc = "Diff" } },
        {
            action = "<cmd>Gitsigns toggle_deleted<CR>",
            key = "<C-g>D",
            mode = "n",
            options = { desc = "Toggle deleted" },
        },
        {
            action = function()
                vim.fn.setreg("", require("gitlinker").get_buf_range_url("n"))
            end,
            key = "<C-g>l",
            mode = "n",
            options = { desc = "Copy line url" },
        },
        {
            action = function()
                vim.fn.setreg("", require("gitlinker").get_buf_range_url("v"))
            end,
            key = "<C-g>l",
            mode = "v",
            options = { desc = "Copy line url" },
        },
        {
            action = function()
                vim.fn.setreg("", require("gitlinker").get_repo_url())
            end,
            key = "<C-g>h",
            mode = "n",
            options = { desc = "Copy homepage" },
        },
        { action = "<cmd>LazyGit<CR>", key = "<C-g>g", mode = "n", options = { desc = "Open lazygit" } },
        { action = "<cmd>Neotree toggle<CR>", key = "<leader>e", mode = "n", options = { desc = "Toggle NeoTree" } },
        { action = "<cmd>noh<CR>", key = "<leader>u", mode = "n", options = { desc = "Clear highlight" } },
        { action = "<cmd>w<CR>", key = "<leader>w", mode = "n", options = { desc = "Save" } },
        {
            action = function()
                vim.o.relativenumber = not vim.o.relativenumber
            end,
            key = "<leader>n",
            mode = "n",
            options = { desc = "Toggle relative" },
        },
        { action = "<cmd>EasyAlign", key = "<leader>a", mode = "n", options = { desc = "Align" } },
        { action = "<cmd>Telescope<CR>", key = "<leader>tt", mode = "n", options = { desc = "All" } },
        {
            action = function()
                vim.diagnostic.open_float()
            end,
            key = "<leader>d",
            mode = "n",
            options = { desc = "Diagnostic" },
        },
        { action = ":IncRename ", key = "<leader>r", mode = "n", options = { desc = "Rename" } },
        { action = "<cmd>Telescope buffers<CR>", key = "<leader>tb", mode = "n", options = { desc = "Buffers" } },
        { action = "<cmd>Telescope fd<CR>", key = "<leader>tf", mode = "n", options = { desc = "Files" } },
        { action = "<cmd>Telescope live_grep<CR>", key = "<leader>tg", mode = "n", options = { desc = "Search" } },
        {
            action = "<cmd>Telescope grep_string<CR>",
            key = "<leader>ts",
            mode = "n",
            options = { desc = "Search word" },
        },
    }
    for i, map in ipairs(__nixvim_binds) do
        vim.keymap.set(map.mode, map.key, map.action, map.options)
    end
end
-- }}}

require("flatten").setup()
require("lsp_signature").setup({
    fix_pos = true,
    handler_opts = { border = "none" },
    hint_prefix = "? ",
})

vim.filetype.add({
    pattern = { [".*/hypr/.*%.conf"] = "hyprlang" },
})

-- Set up autogroups {{
do
    local __nixvim_autogroups = { nixvim_binds_LspAttach = { clear = true } }

    for group_name, options in pairs(__nixvim_autogroups) do
        vim.api.nvim_create_augroup(group_name, options)
    end
end
-- }}
-- Set up autocommands {{
do
    local __nixvim_autocommands = {
        {
            callback = function()
                do
                    local __nixvim_binds = {}
                    for i, map in ipairs(__nixvim_binds) do
                        vim.keymap.set(map.mode, map.key, map.action, map.options)
                    end
                end
            end,
            desc = "Load keymaps for LspAttach",
            event = "LspAttach",
            group = "nixvim_binds_LspAttach",
        },
        { command = "set commentstring='# %s'", event = { "BufNewFile", "BufRead" }, pattern = "**/hypr/**/*.conf" },
        {
            callback = function()
                vim.o.wrap = true
                vim.o.linebreak = true
                vim.keymap.set("i", "<Esc>", "<Esc><cmd>sil w<CR>", { buffer = vim.fn.bufnr("%") })
            end,
            event = { "BufNewFile", "BufRead" },
            pattern = "/home/readf0x/Obsidian/**/*.md",
        },
        {
            callback = function()
                vim.cmd('sil !xdg-open "obsidian://open?path=' .. vim.fn.getcwd() .. "/" .. vim.fn.expand("%") .. '"')
            end,
            event = { "BufEnter" },
            pattern = "/home/readf0x/Obsidian/**/*.md",
        },
        {
            callback = function()
                if started == nil then
                    started = os.time()
                end
                if os.time() > started then
                    vim.cmd("silent write")
                    started = os.time()
                end
            end,
            event = { "TextChanged", "TextChangedI", "ModeChanged" },
            pattern = "*.md",
        },
        {
            callback = function()
                MiniPairs.map_buf(
                    vim.fn.bufnr("%"),
                    "i",
                    "=",
                    { action = "open", pair = "=;", register = { cr = false } }
                )
                MiniPairs.map_buf(
                    vim.fn.bufnr("%"),
                    "i",
                    ";",
                    { action = "close", pair = "=;", register = { cr = false } }
                )

                vim.keymap.set("i", "<C-e>", function()
                    require("luasnip").snip_expand(require("luasnip").get_snippets().nix[1])
                end, { buffer = vim.fn.bufnr("%") })
                vim.keymap.set("i", "<M-C-E>", function()
                    require("luasnip").snip_expand(require("luasnip").get_snippets().nix[3])
                end, { buffer = vim.fn.bufnr("%") })
                vim.keymap.set(
                    "n",
                    "<leader>bh",
                    "<cmd>!home-manager switch --flake .<CR>",
                    { buffer = vim.fn.bufnr("%"), desc = "Build Home-Manager" }
                )
                vim.keymap.set(
                    "n",
                    "<leader>bt",
                    "<cmd>!sudo nixos-rebuild test --flake .<CR>",
                    { buffer = vim.fn.bufnr("%"), desc = "System rebuild test" }
                )
                vim.keymap.set(
                    "n",
                    "<leader>br",
                    "<cmd>!sudo nixos-rebuild switch --flake .<CR>",
                    { buffer = vim.fn.bufnr("%"), desc = "System rebuild switch" }
                )
            end,
            event = { "BufNewFile", "BufRead" },
            pattern = "*.nix",
        },
        { command = "set filetype=markdown", event = { "BufNewFile", "BufRead" }, pattern = "github.com_*.txt" },
    }

    for _, autocmd in ipairs(__nixvim_autocommands) do
        vim.api.nvim_create_autocmd(autocmd.event, {
            group = autocmd.group,
            pattern = autocmd.pattern,
            buffer = autocmd.buffer,
            desc = autocmd.desc,
            callback = autocmd.callback,
            command = autocmd.command,
            once = autocmd.once,
            nested = autocmd.nested,
        })
    end
end
-- }}

require("telescope").load_extension("zoxide")
vim.keymap.del("n", "<leader>gy")
if vim.g.started_by_firenvim == true then
    vim.cmd("colorscheme default")
end
local ls = require("luasnip")
local t = ls.text_node
local i = ls.insert_node
ls.add_snippets("go", {
    ls.snippet("en", {
        t({ "if err != nil {", "\t" }),
        i(1),
        t({ "", "}" }),
    }),
})
ls.add_snippets("nix", {
    ls.snippet("e", {
        t("enable = true;"),
    }),
    ls.snippet("ed", {
        t(".enable = true;"),
    }),
    ls.snippet("ea", {
        t({ " = {", "\tenable = true;" }),
        t({ "", "\t" }),
        i(1),
        t({ "", "};" }),
    }),
    ls.snippet("''", {
        t({ "''" }),
        t({ "" }),
        i(0),
        t({ "", "''" }),
    }),
    ls.snippet("ml", {
        t({ "''" }),
        t({ "" }),
        i(0),
        t({ "", "''" }),
    }),
})

Here are the extra plugins I'm using

extraPlugins = with pkgs.vimPlugins; [
  firenvim
  flatten-nvim
  lsp_signature-nvim
  telescope-zoxide
  tender-vim
  vim-easy-align
  zoxide-vim
];

This issue occured on a smaller scale a while ago, so I had some items sourced manually. It's been a while, but I believe without those it will fail in setup.

It fails to set the colorscheme to tender initially:

Error detected while processing /home/readf0x/.config/nvim/init.lua:                                                                                                                            
E5113: Error while calling lua chunk: vim/_editor.lua:0: /home/readf0x/.config/nvim/init.lua..nvim_exec2() called at /home/readf0x/.config/nvim/init.lua:0: Vim(colorscheme):E185: Cannot find c
olor scheme 'tender'                                                                                                                                                                            
stack traceback:                                                                                                                                                                                
        [C]: in function 'nvim_exec2'                                                                                                                                                           
        vim/_editor.lua: in function 'cmd'                                                                                                                                                      
        /home/readf0x/.config/nvim/init.lua:27: in main chunk

If I disable my colorscheme, I get this error instead:

Error detected while processing /home/readf0x/.config/nvim/init.lua:                                                                                                                            
E5113: Error while calling lua chunk: /home/readf0x/.config/nvim/init.lua:51: module 'cmp' not found:                                                                                           
        no field package.preload['cmp']                                                                                                                                                         
        no file '/nix/store/lr25j79n6rshcpifx3490kjrnkr4xngm-luajit-2.1.1713773202-env/share/lua/5.1/cmp.lua'                                                                                   
        no file '/nix/store/lr25j79n6rshcpifx3490kjrnkr4xngm-luajit-2.1.1713773202-env/share/lua/5.1/cmp/init.lua'                                                                              
        no file '/nix/store/lr25j79n6rshcpifx3490kjrnkr4xngm-luajit-2.1.1713773202-env/lib/lua/5.1/cmp.so'                                                                                      
stack traceback:                                                                                                                                                                                
        [C]: in function 'require'                                                                                                                                                              
        /home/readf0x/.config/nvim/init.lua:51: in main chunk

[GaetanLepage]

Is the cmp plugin enabled on the nix side ?
It would be great if you could reduce your example to a minimal case that reproduces the error.

[Readf0x]

It appears that on a fresh install when deploying through home-manager, it is unable to source/require the majority of plugins. I did not have the time to go through and disable every plugin until it worked, as it just kept failing to use another one. So for now I have changed my setup to use the standalone, and everything is using nix run. If anyone is interested in testing the issue, my dotfiles are available at readf0x/dotfiles.