feat: improve startup time by caching

Author: cpea2506

colors/one_monokai.lua

@@ -1 +1 @@
-require("one_monokai").setup()
+require("one_monokai").load()

lua/one_monokai/config.lua

@@ -5,13 +5,15 @@ local config = {}
 ---@field colors colors #Custom colors
 ---@field themes fun(colors:colors):groups #Custom highlight groups
 ---@field italics boolean #Whether to italicize some highlight groups
+---@field compile_path string #Path to store compiled result.
 local defaults = {
     transparent = false,
     colors = {},
     themes = function(_)
         return {}
     end,
     italics = true,
+    compile_path = vim.fn.stdpath "cache" .. "/one_monokai",
 }
 
 config.options = vim.deepcopy(defaults)

lua/one_monokai/init.lua

@@ -1,27 +1,60 @@
 local M = {}
 
-function M.setup(opts)
-    local set = vim.cmd
-    local config = require "one_monokai.config"
-    local themes = require "one_monokai.themes"
+local did_setup = false
+local config = require "one_monokai.config"
+local compiler = require "one_monokai.lib.compiler"
+local utils = require "one_monokai.utils"
 
-    if vim.g.colors_name then
-        set.hi "clear"
+function M.load()
+    if not did_setup then
+        M.setup()
     end
 
-    if vim.fn.exists "syntax_on" then
-        set.syntax "reset"
+    local compiled_path = utils.join_paths(config.compile_path, "themes")
+    local f = loadfile(compiled_path)
+
+    if not f then
+        compiler.compile()
+
+        f = assert(loadfile(compiled_path), "could not load cache")
     end
 
-    vim.o.background = "dark"
-    vim.o.termguicolors = true
-    vim.g.colors_name = "one_monokai"
+    f()
+end
+
+function M.setup(opts)
+    local hasher = require "one_monokai.lib.hasher"
 
+    did_setup = true
     config:extend(opts)
-    themes.load()
 
-    if opts then
-        set.colorscheme "one_monokai"
+    -- Get cached hash
+    local cached_hash_path = utils.join_paths(config.compile_path, "hash")
+    local file = io.open(cached_hash_path)
+    local cached_hash = nil
+
+    if file then
+        cached_hash = file:read()
+        file:close()
+    end
+
+    -- Get current hash
+    local git_path = debug.getinfo(1).source:sub(2, -24) .. ".git"
+    local git = vim.fn.getftime(git_path) -- 2x faster vim.loop.fs_stat
+    local hash = hasher.hash(config.options)
+        .. (git == -1 and git_path or git) -- no .git in /nix/store -> cache path
+        .. (vim.o.winblend == 0 and 1 or 0) -- :h winblend
+        .. (vim.o.pumblend == 0 and 1 or 0) -- :h pumblend
+
+    -- Recompile if hash changed
+    if cached_hash ~= hash then
+        compiler.compile()
+        file = io.open(cached_hash_path, "wb")
+
+        if file then
+            file:write(hash)
+            file:close()
+        end
     end
 end
 

lua/one_monokai/lib/bitlib.lua

@@ -0,0 +1,101 @@
+---@source: https://github.com/davidm/lua-bit-numberlua/blob/master/lmod/bit/numberlua.lua
+---@class bitlib
+local bitlib = {}
+
+local MOD = 2 ^ 32
+local floor = math.floor
+
+local function memoize(f)
+    local mt = {}
+    local t = setmetatable({}, mt)
+
+    function mt:__index(k)
+        local v = f(k)
+        t[k] = v
+
+        return v
+    end
+
+    return t
+end
+
+local function make_bitop_uncached(t, m)
+    local function bitop(a, b)
+        local res, p = 0, 1
+
+        while a ~= 0 and b ~= 0 do
+            local am, bm = a % m, b % m
+            res = res + t[am][bm] * p
+            a = (a - am) / m
+            b = (b - bm) / m
+            p = p * m
+        end
+
+        res = res + (a + b) * p
+
+        return res
+    end
+
+    return bitop
+end
+
+local function make_bitop(t)
+    local op1 = make_bitop_uncached(t, 2 ^ 1)
+    local op2 = memoize(function(a)
+        return memoize(function(b)
+            return op1(a, b)
+        end)
+    end)
+
+    return make_bitop_uncached(op2, 2 ^ (t.n or 1))
+end
+
+bitlib.bxor = make_bitop { [0] = { [0] = 0, [1] = 1 }, [1] = { [0] = 1, [1] = 0 }, n = 4 }
+local bxor = bitlib.bxor
+
+local lshift, rshift
+
+-- Lua5.2 inspired
+lshift = function(a, disp)
+    if disp < 0 then
+        return rshift(a, -disp)
+    end
+
+    return (a * 2 ^ disp) % 2 ^ 32
+end
+
+-- Lua5.2 inspired
+rshift = function(a, disp)
+    if disp < 0 then
+        return lshift(a, -disp)
+    end
+
+    return floor(a % 2 ^ 32 / 2 ^ disp)
+end
+
+local function bit_tobit(x)
+    x = x % MOD
+
+    if x >= 0x80000000 then
+        x = x - MOD
+    end
+
+    return x
+end
+
+local function bit_bxor(a, b, c, ...)
+    if c then
+        return bit_bxor(bit_bxor(a, b), c, ...)
+    elseif b then
+        return bit_tobit(bxor(a % MOD, b % MOD))
+    else
+        return bit_tobit(a)
+    end
+end
+
+return {
+    bxor = bit_bxor,
+    lshift = function(x, n)
+        return bit_tobit(lshift(x % MOD, n % 32))
+    end,
+}

lua/one_monokai/lib/compiler.lua

@@ -0,0 +1,93 @@
+---@class compiler
+---@source: https://github.com/catppuccin/nvim
+local compiler = {}
+
+local fmt = string.format
+local utils = require "one_monokai.utils"
+
+local function inspect(attr)
+    local list = {}
+
+    for key, value in pairs(attr) do
+        local t = type(value)
+
+        if t == "string" then
+            table.insert(list, fmt([[%s = "%s"]], key, value))
+        else
+            table.insert(list, fmt("%s = %s", key, t == table and inspect(value) or tostring(value)))
+        end
+    end
+
+    return fmt([[{ %s }]], table.concat(list, ", "))
+end
+
+function compiler.compile()
+    local config = require "one_monokai.config"
+    local themes = require "one_monokai.themes"
+    local cached_themes_path = utils.join_paths(config.compile_path, "themes")
+
+    local lines = {
+        [[
+return string.dump(function()
+local hi = vim.api.nvim_set_hl
+if vim.g.colors_name then vim.cmd.hi "clear" end
+vim.o.termguicolors = true
+vim.g.colors_name = "one_monokai"
+vim.o.background = "dark"
+]],
+    }
+
+    for name, attrs in pairs(themes.groups) do
+        for _, attr in pairs(attrs) do
+            if not config.italics and attr == "italic" then
+                attrs[attr] = false
+            end
+        end
+
+        table.insert(lines, fmt([[hi(0, "%s", %s)]], name, inspect(attrs)))
+    end
+
+    table.insert(lines, "end, true)")
+
+    if vim.fn.isdirectory(config.compile_path) == 0 then
+        vim.fn.mkdir(config.compile_path, "p")
+    end
+
+    local f = loadstring(table.concat(lines, "\n"))
+
+    if not f then
+        local err_path = os.getenv "TMP" .. "/one_monokai_error.lua"
+
+        print(string.format(
+            [[One Monokai (error): Most likely some mistake made in your One Monokai config
+You can open %s for debugging
+
+If you think this is a bug, kindly open an issue and attach %s file
+Below is the error message that we captured:
+]],
+            err_path,
+            err_path
+        ))
+
+        local err = io.open(err_path, "wb")
+
+        if err then
+            err:write(table.concat(lines, "\n"))
+            err:close()
+        end
+
+        dofile(err_path)
+
+        return
+    end
+
+    local file = assert(
+        io.open(cached_themes_path, "wb"),
+        "Permission denied while writing compiled file to " .. config.compile_path
+    )
+
+    file:write(f())
+    file:close()
+end
+
+return compiler

lua/one_monokai/lib/hasher.lua

@@ -0,0 +1,37 @@
+---@class hasher
+local hasher = {}
+
+local bitlib = bit or bit32 or require "one_monokai.lib.bitlib"
+
+---@source: https://theartincode.stanis.me/008-djb2/
+local function hash_str(str)
+    local hash = 5381
+
+    for i = 1, #str do
+        hash = bitlib.lshift(hash, 5) + hash + string.byte(str, i)
+    end
+
+    return hash
+end
+
+---@source https://codeforces.com/blog/entry/85900
+function hasher.hash(value)
+    local colors = require "one_monokai.colors"
+    local t = type(value)
+
+    if t == "table" then
+        local hash = 0
+
+        for p, u in next, value do
+            hash = bitlib.bxor(hash, hash_str(p .. hasher.hash(u)))
+        end
+
+        return hash
+    elseif t == "function" then
+        return hasher.hash(value(colors))
+    end
+
+    return tostring(value)
+end
+
+return hasher

lua/one_monokai/themes/groups.lua renamed to lua/one_monokai/themes.lua

@@ -1,10 +1,9 @@
----@class groups
-local groups = {}
+---@class themes
+local themes = {}
 
 local colors = require "one_monokai.colors"
 local config = require "one_monokai.config"
 
----@type groups
 local defaults = {
     Boolean = { fg = colors.cyan },
     Character = { fg = colors.yellow },
@@ -572,6 +571,10 @@ for _, semantic_group in ipairs(vim.fn.getcompletion("@lsp", "highlight")) do
     end
 end
 
-groups = vim.deepcopy(defaults)
+themes.groups = vim.deepcopy(defaults)
 
-return groups
+for name, attrs in pairs(config.themes(colors)) do
+    themes.groups[name] = attrs
+end
+
+return themes

lua/one_monokai/themes/init.lua

@@ -0,0 +1,9 @@
+local utils = {}
+
+function utils.join_paths(...)
+    local separator = jit and (jit.os == "Windows" and "\\" or "/") or string.sub(package.config, 1, 1)
+
+    return table.concat({ ... }, separator)
+end
+
+return utils