dotfiles/.config/nvim/lua/plugins/linting.lua

return {
    "mfussenegger/nvim-lint",
    event = { "BufReadPre", "BufNewFile" },
    config = function()
        local lint = require("lint")

        local severities = {
            ERROR = vim.diagnostic.severity.ERROR,
            WARNING = vim.diagnostic.severity.WARN,
        }

        lint.linters.phpcs = {
            name = "phpcs",
            cmd = "phpcs",
            stdin = true,
            args = {
                "-q",
                "--report=json",
                "--standard=~/.config/phpcs.xml",
                "-", -- need `-` at the end for stdin support
            },
            ignore_exitcode = true,
            parser = function(output, _)
                if vim.trim(output) == "" or output == nil then
                    return {}
                end

                if not vim.startswith(output, "{") then
                    vim.notify(output)
                    return {}
                end

                local decoded = vim.json.decode(output)
                local diagnostics = {}
                local messages = decoded["files"]["STDIN"]["messages"]

                for _, msg in ipairs(messages or {}) do
                    table.insert(diagnostics, {
                        lnum = msg.line - 1,
                        end_lnum = msg.line - 1,
                        col = msg.column - 1,
                        end_col = msg.column - 1,
                        message = msg.message,
                        code = msg.source,
                        source = "phpcs",
                        severity = assert(severities[msg.type], "missing mapping for severity " .. msg.type),
                    })
                end

                return diagnostics
            end,
        }

        lint.linters_by_ft = {
            javascript = { "eslint" },
            typescript = { "eslint" },
            vue = { "eslint" },
            json = { "jsonlint" },
            markdown = { "markdownlint" },
            php = { "phpcs" },
            golang = { "gospell", "golangci-lint" },
            python = { "pylint" },
            dockerfile = { "hadolint" },
            blade = { "phpcs" },
            html = { "curlylint" },
        }

        local lint_augroup = vim.api.nvim_create_augroup("lint", {
            clear = true,
        })


        local function find_nearest_node_modules_dir()
            -- current buffer dir
            local current_dir = vim.fn.expand('%:p:h') .. "./frontend"
            while current_dir ~= "/" do
                if vim.fn.isdirectory(current_dir .. "/node_modules") == 1 then
                    return current_dir
                end
                current_dir = vim.fn.fnamemodify(current_dir, ":h")
            end
            return nil
        end

        vim.api.nvim_create_autocmd({
            "BufEnter",
            "BufWritePost",
            "InsertLeave",
        }, {
            group = lint_augroup,
            callback = function()
                local ft = vim.bo.filetype
                local js_types = { "javascript", "typescript", "javascriptreact", "typescriptreact", "vue" }
                if not vim.tbl_contains(js_types, ft) then
                    lint.try_lint()
                    return
                end
                local original_cwd = vim.fn.getcwd()
                local node_modules_dir = find_nearest_node_modules_dir()
                if node_modules_dir then
                    vim.cmd("cd " .. node_modules_dir)
                end
                lint.try_lint()
                vim.cmd("cd " .. original_cwd)
            end,
        })

        -- vim.keymap.set("n", "<leader>ll", function()
        -- 	lint.try_lint()
        -- end)
    end,
}