refactor: extract all dep logic in Dep object

lib/deps.nix

@@ -81,9 +81,9 @@
       buildPhase = ''
         dir=lua/sloth-flake
         mkdir -p $dir
-        mv init.lua $dir
+        mv *.lua $dir
 
-        cat <<'LUA' > $dir/deps.lua
+        cat <<'LUA' > $dir/dependencies.lua
         ${pluginsLuaDef plugins}
         LUA
 

lua/sloth-flake/dep.lua

@@ -0,0 +1,178 @@
+local raw_deps = require 'sloth-flake.dependencies'
+
+local M = {}
+
+function M.new(values)
+  return setmetatable({
+    priv = {
+      init = false,
+      import = false,
+      config = false,
+      shim = false,
+    },
+    values = values,
+  }, {
+    __index = M,
+  })
+end
+
+function M:name()
+  return self.values.name
+end
+
+function M:dependencies()
+  local ret = {}
+  for _, name in ipairs(self.values.dependencies) do
+    local dep = M.get(name)
+    if dep ~= nil then
+      ret[#ret + 1] = dep
+    end
+  end
+  return ret
+end
+
+function M:cmd()
+  return self.values.cmd
+end
+
+function M:ft()
+  return self.values.ft
+end
+
+function M:is_lazy()
+  return self.values.lazy or false
+end
+
+function M:is_imported()
+  return self.priv.import
+end
+
+function M:is_loaded()
+  -- last step is config, so a plugin is loaded if its config has run
+  return self.priv.config
+end
+
+function load_fn(type)
+  local function fn(self)
+    if self.priv[type] then
+      return
+    end
+    self.priv[type] = true
+
+    for _, dep in ipairs(self:dependencies()) do
+      fn(dep)
+    end
+
+    if self.values[type] ~= nil then
+      self.values[type]()
+    end
+  end
+  return fn
+end
+
+M.init = load_fn('init')
+M.config = load_fn('config')
+
+function M:import()
+  if self:is_imported() then
+    return
+  end
+  self.priv.import = true
+
+  for _, dep in ipairs(self:dependencies()) do
+    dep:import()
+  end
+
+  if self:is_lazy() then
+    vim.cmd("packadd " .. self:name())
+  end
+end
+
+function M:load()
+  -- unshim_plugin(name)
+  self:unshim()
+  self:init()
+  self:import()
+  self:config()
+end
+
+function M:augroup_name()
+  return "Sloth-plugin-" .. self:name()
+end
+
+function M:lazy_load_cmd(cmd)
+  return function(param)
+    self:load()
+    local bang = param.bang and '!' or ''
+    vim.cmd(cmd .. bang .. ' ' .. param.args)
+  end
+end
+
+function M:lazy_load_ft()
+  return function(param)
+    self:load()
+    vim.api.nvim_exec_autocmds('FileType', {
+      pattern = param.match,
+    })
+  end
+end
+
+function M:shim()
+  if self.priv.shim then
+    return
+  end
+  self.priv.shim = true
+
+  if self:cmd() then
+    for _, cmd in ipairs(self:cmd()) do
+      vim.api.nvim_create_user_command(cmd, self:lazy_load_cmd(cmd), {
+        desc = "Sloth-flake placeholder for plugin " .. self:name(),
+        nargs = '*',
+        bang = true,
+      })
+    end
+  end
+
+  if self:ft() then
+    local group_id = vim.api.nvim_create_augroup(self:augroup_name(), {
+      clear = true,
+    })
+    vim.api.nvim_create_autocmd('FileType', {
+      group = group_id,
+      pattern = self:ft(),
+      callback = self:lazy_load_ft()
+    })
+  end
+end
+
+function M:unshim()
+  if not self.priv.shim then
+    return
+  end
+  self.priv.shim = nil
+
+  if self:cmd() then
+    for _, cmd in ipairs(self:cmd()) do
+      vim.api.nvim_del_user_command(cmd)
+    end
+  end
+
+  if self:ft() then
+    vim.api.nvim_del_augroup_by_name(self:augroup_name())
+  end
+end
+
+local deps = {}
+for k, v in pairs(raw_deps) do
+  deps[k] = M.new(v)
+end
+
+function M.get(name)
+  return deps[name]
+end
+
+function M.all()
+  return deps
+end
+
+return M

lua/sloth-flake/init.lua

@@ -1,197 +1,56 @@
-local deps = require 'sloth-flake.deps'
+local Dep = require 'sloth-flake.dep'
 local priv = {
   setup_called = false,
-  is = {
-    init = {},
-    import = {},
-    config = {},
-    shim = {},
-  },
 }
 
 local M = {}
 
 function M.get(name)
-  return deps[name]
+  return Dep.get(name)
 end
 
 function M.init_non_lazy()
   for _, dep in ipairs(M.non_lazy_deps()) do
-    M.init(dep.name)
+    dep:init()
   end
 end
 
 function M.import_non_lazy()
   for _, dep in ipairs(M.non_lazy_deps()) do
-    M.import(dep.name)
+    dep:import()
   end
 end
 
 function M.config_non_lazy()
   for _, dep in ipairs(M.non_lazy_deps()) do
-    M.config(dep.name)
+    dep:config()
   end
 end
 
-function load_fn(type)
-  local function fn(name)
-    local dep = M.get(name)
-    if dep == nil then
-      -- TODO Handle missing deps
-      return
-    end
-    if priv.is[type][name] then
-      return
-    end
-    priv.is[type][name] = true
-    if dep[type] ~= nil then
-      for _, child in ipairs(dep.dependencies) do
-        fn(child)
-      end
-      dep[type]()
-    end
-  end
-  return fn
-end
-
-M.init = load_fn('init')
-M.config = load_fn('config')
-
-function M.import(name)
-  if M.is_imported(name) then
-    return
-  end
-  local plugin = M.get(name)
-  if plugin == nil then
-    -- TODO Handle missing deps
-    return
-  end
-  priv.is.import[name] = true
-  if plugin.lazy then
-    for _, dep in ipairs(plugin.dependencies) do
-      M.import(dep)
-    end
-    vim.cmd("packadd " .. name)
-  end
-end
-
-function M.is_imported(name)
-  return priv.is.import[name] or false
-end
-
-function M.is_loaded(name)
-  return priv.is.config[name] or false
-end
-
-function M.load(name)
-  unshim_plugin(name)
-  M.init(name)
-  M.import(name)
-  M.config(name)
-end
-
 function M.dep_names()
   return M.dep_names_by(function() return true end):totable()
 end
 
 function M.dep_names_by(fn)
-  return M.deps_iter_by(fn):map(function(v) return v.name end)
+  return M.deps_iter_by(fn):map(function(v) return v:name() end)
 end
 
 function M.deps_iter_by(fn)
-  return vim.iter(deps):map(function(k, v) return v end):filter(fn)
+  return vim.iter(Dep.all()):map(function(k, v) return v end):filter(fn)
 end
 
 function M.non_lazy_deps()
   return M.deps_iter_by(function(dep)
-    return not dep.lazy
+    return not dep:is_lazy()
   end):totable()
 end
 
 function M.lazy_deps()
   return M.deps_iter_by(function(dep)
-    return dep.lazy
+    return dep:is_lazy()
   end):totable()
 end
 
-function lazy_load_cmd(dep, cmd)
-  return function(param)
-    M.load(dep.name)
-    local bang = param.bang and '!' or ''
-    vim.cmd(cmd .. bang .. ' ' .. param.args)
-  end
-end
-
-function lazy_load_ft(dep)
-  return function(param)
-    M.load(dep.name)
-    print(param.match)
-    vim.api.nvim_exec_autocmds('FileType', {
-      pattern = param.match,
-    })
-  end
-end
-
-function augroup_name(dep)
-  return "Sloth-plugin-" .. dep.name
-end
-
-function shim_plugin(dep)
-  if priv.is.shim[dep.name] then
-    return
-  end
-  priv.is.shim[dep.name] = true
-
-  if dep.cmd then
-    for _, cmd in ipairs(dep.cmd) do
-      vim.api.nvim_create_user_command(cmd, lazy_load_cmd(dep, cmd), {
-        desc = "Sloth-flake placeholder for plugin " .. dep.name,
-        nargs = '*',
-        bang = true,
-      })
-    end
-  end
-
-  if dep.ft then
-    local group_id = vim.api.nvim_create_augroup(augroup_name(dep), {
-      clear = true,
-    })
-    vim.api.nvim_create_autocmd('FileType', {
-      group = group_id,
-      pattern = dep.ft,
-      callback = lazy_load_ft(dep)
-    })
-  end
-end
-
-function unshim_plugin(name)
-  local dep = M.get(name)
-  if not priv.is.shim[name] then
-    return
-  end
-  priv.is.shim[name] = nil
-
-  if dep.cmd then
-    for _, cmd in ipairs(dep.cmd) do
-      vim.api.nvim_del_user_command(cmd)
-    end
-  end
-
-  if dep.ft then
-    vim.api.nvim_del_augroup_by_name(augroup_name(dep))
-  end
-end
-
-function name_compare(a, b)
-  if a < b then
-    return -1
-  elseif a > b then
-    return 1
-  else
-    return 0
-  end
-end
-
 local function vim_error(...)
   vim.api.nvim_err_writeln(string.format(...))
 end
@@ -204,11 +63,11 @@ local commands = {
       -- Nothing to do
     elseif filter == "loaded" then
       deps = deps:filter(function (dep)
-        return M.is_loaded(dep)
+        return Dep.get(dep):is_loaded()
       end)
     elseif filter == "notloaded" then
       deps = deps:filter(function (dep)
-        return not M.is_loaded(dep)
+        return not Dep.get(dep):is_loaded()
       end)
     else
       vim_error([[No Sloth list filter "%s".]], cmd)
@@ -216,7 +75,7 @@ local commands = {
       return
     end
     deps = deps:totable()
-    table.sort(deps, dep_name_compare)
+    table.sort(deps)
     for _, dep in ipairs(deps) do
       print(string.format("- %s", dep))
     end
@@ -228,7 +87,10 @@ local commands = {
       return
     end
     for _, plugin in ipairs(plugins) do
-      M.load(plugin)
+      local dep = M.get(plugin)
+      if dep ~= nil then
+        dep:load()
+      end
     end
   end,
 
@@ -271,7 +133,7 @@ function M.setup(config)
 
   local lazy_deps = M.lazy_deps()
   for _, dep in ipairs(lazy_deps) do
-    shim_plugin(dep)
+    dep:shim()
   end
 
   register_command()