1

use flake

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

-- 以下はlazy.nvimから読み込まれるとする
{
  'actionshrimp/direnv.nvim',
  opts = {
    async = true,
    type = 'dir', -- ディレクトリ移動でフックする場合
    --type = 'buffer', -- バッファの読み込みでフックする場合
    on_direnv_finished = function() -- 実行後に実行される関数
      print('direnv: ok!')
    end,
  },
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

-- 別のファイルに記述した以下が`lazy.nvim`によって読み込まれるように設定されているものとする
--[[ 
local ressesion = {
  'stevearc/resession.nvim',
  opts = {},
}
--]]

local resession = require('resession')

resession.setup({
  extensions = {
    actionshrimp_direnv = {},
  },
})

-- Resession does NOTHING automagically, so we have to set up some keymaps
vim.keymap.set('n', '<leader>ss', resession.save)
vim.keymap.set('n', '<leader>sl', resession.load)
vim.keymap.set('n', '<leader>sd', resession.delete)

1
2
3

  -- Don't trigger autocmds during session load
  local eventignore = vim.o.eventignore
  vim.o.eventignore = "all"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

  local last_bufnr
  for _, buf in ipairs(data.buffers) do
    local bufnr = vim.fn.bufadd(buf.name)
    last_bufnr = bufnr

    if buf.loaded then
      vim.fn.bufload(bufnr)
      vim.b[bufnr]._resession_need_edit = true
      vim.b[bufnr].resession_restore_last_pos = true
      vim.api.nvim_create_autocmd("BufEnter", {
        desc = "Resession: complete setup of restored buffer",
        callback = function(args)
          if vim.b[args.buf].resession_restore_last_pos then
            pcall(vim.api.nvim_win_set_cursor, 0, buf.last_pos)
            vim.b[args.buf].resession_restore_last_pos = nil
          end
          -- This triggers the autocmds that set filetype, syntax highlighting, and checks the swapfile
          if vim.b._resession_need_edit then
            vim.b._resession_need_edit = nil
            vim.cmd.edit({ mods = { emsg_silent = true } })
          end
        end,
        buffer = bufnr,
        once = true,
        nested = true,
      })
    end
    util.restore_buf_options(bufnr, buf.options)
  end

1
2
3
4

  -- Ensure the cwd is set correctly for each loaded buffer
  if not data.tab_scoped then
    vim.api.nvim_set_current_dir(data.global.cwd)
  end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

  for ext_name in pairs(config.extensions) do
    if data[ext_name] then
      local ext = util.get_extension(ext_name)
      if ext and ext.on_post_load then
        local ok, err = pcall(ext.on_post_load, data[ext_name])
        if not ok then
          vim.notify(
            string.format('[resession] Extension "%s" on_post_load error: %s', ext_name, err),
            vim.log.levels.ERROR
          )
        end
      end
    end
  end

1
2
3
4
5
6
7
8
9

local M = {}

---Restore the extension state
---@param data The value returned from on_save
M.on_post_load = function(data)
  -- This is run after the buffers, windows, and tabs are restored
end

return M

1
2
3
4
5
6
7

require("resession").setup({
  extensions = {
    <extension name> = {
      -- these args will get passed in to M.config()
    },
  },
})

1
2

  vim.o.eventignore = eventignore
  vim.o.shortmess = shortmess

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

local M = {}

M.on_save = function()
  local project_dir_prev_session = vim.fn.getcwd()
  return { project_dir = project_dir_prev_session }
end

M.on_post_load = function(data)
  print(string.format('move to project dir: %s', data.project_dir))
  require('direnv-nvim').hook()
end

return M

1
2
3
4
5

resession.setup({
  extensions = {
    actionshrimp_direnv = {},
  },
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

M.setup = function(opts)
	OPTS = vim.tbl_deep_extend("force", OPTS, opts)
	M.OPTS = OPTS
	if OPTS.type == "buffer" then
		setup_buffer()
	end
	if OPTS.type == "dir" then
		setup_dir()
	end
	if OPTS.on_direnv_finished ~= nil then
		local au_opts = OPTS.on_direnv_finished_opts

		vim.api.nvim_create_autocmd("User", {
			pattern = au_opts["pattern"],
			group = "direnv-nvim",
			once = au_opts["once"],
			callback = function(args)
				if
					au_opts["filetype"] == nil
					or (au_opts["filetype"] == vim.bo[args.buf].filetype or _has_filetype(au_opts["filetype"], vim.bo[args.buf].filetype))
				then
					OPTS.on_direnv_finished({
						buffer = args.buf,
						filetype = vim.bo[args.buf].filetype,
					})
				end
			end,
		})
	end
end

1
2
3
4
5
6
7
8

local setup_buffer = function()
	vim.api.nvim_create_autocmd(OPTS.buffer_setup.autocmd_event, {
		pattern = OPTS.buffer_setup.autocmd_pattern,
		callback = function()
			M.hook()
		end,
	})
end

1
2
3
4
5
6
7
8

local setup_dir = function()
	vim.api.nvim_create_autocmd(OPTS.dir_setup.autocmd_event, {
		pattern = OPTS.dir_setup.autocmd_pattern,
		callback = function()
			M.hook()
		end,
	})
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

M.hook = function()
	local cwd = get_cwd()
	if cwd ~= nil then
		if rc_found(cwd) and rc_allowed(cwd) then
			M.hook_(cwd)
		elseif rc_found(cwd) then
			vim.notify("direnv environment is blocked, please 'direnv allow' it (:DirenvAllow)", vim.log.levels.WARN)
			vim.api.nvim_exec_autocmds("User", { pattern = "DirenvBlocked", group = augroup })
		else
			vim.api.nvim_exec_autocmds("User", { pattern = "DirenvNotFound", group = augroup })
		end
	end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

M.hook_ = function(cwd)
	vim.api.nvim_exec_autocmds("User", { pattern = "DirenvStart", group = augroup })
	if OPTS.async then
		vim.system({ "direnv", "export", "json" }, { text = true, cwd = cwd }, function(export_result)
			vim.schedule(function()
				M.hook_body(export_result)
			end)
		end)
	else
		local res = vim.system({ "direnv", "export", "json" }, { text = true, cwd = cwd })
		local export_result = res:wait()
		M.hook_body(export_result)
	end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

M.hook_body = function(export_result)
	if export_result.stdout ~= "" then
		for k, v in pairs(vim.json.decode(export_result.stdout)) do
			if v == vim.NIL then
				vim.env[k] = nil
			else
				vim.env[k] = v
			end
		end

		if OPTS.hook.msg == "diff" then
			local display_msg = export_result.stderr
			if display_msg ~= nil then
				local lines = vim.split(display_msg, "\n", { trimempty = true })
				local diff_msg = lines[#lines]
				if string.len(diff_msg) > vim.o.columns then
					diff_msg = string.sub(diff_msg, 1, vim.o.columns - 20) .. "..."
				end
				vim.cmd("redraw")
				vim.notify(diff_msg, vim.log.levels.INFO)
			end
		elseif OPTS.hook.msg == "status" then
			M.status()
		end
		vim.api.nvim_exec_autocmds("User", { pattern = "DirenvUpdated", group = augroup })
	end
	vim.api.nvim_exec_autocmds("User", { pattern = "DirenvReady", group = augroup })
end

1
2
3
4
5
6
7
8

-- This snippet is more or less what `on_direnv_finished` runs under the hood.
vim.api.nvim_create_autocmd("User", {
        group = "direnv-nvim",
        pattern = { "DirenvReady", "DirenvNotFound" },
        callback = function()
        -- your action here
        end,
})

1
2
3
4
5
6
7

local M = {}

M.on_post_load = function(data)
  require('direnv-nvim').hook()
end

return M

1
2
3
4
5

resession.setup({
  extensions = {
    actionshrimp_direnv = {},
  },
})