Extend state module to include VCS stuff.

lua/vcsigns/actions.lua

···
     group = group,
     buffer = bufnr,
     callback = function()
-      if not vim.b[bufnr].vcsigns_detecting then
+      if not state.get(bufnr).vcs.detecting then
         updates.deep_update(bufnr)
       end
     end,
···
     group = group,
     buffer = bufnr,
     callback = function()
-      if not vim.b[bufnr].vcsigns_detecting then
+      if not state.get(bufnr).vcs.detecting then
         updates.shallow_update(bufnr)
       end
     end,
···
 ---@param bufnr integer The buffer number.
 function M.start(bufnr)
   -- Clear existing state.
-  vim.b[bufnr].vcsigns_detecting = nil
-  vim.b[bufnr].vcsigns_vcs = nil
+  local s = state.get(bufnr)
+  s.vcs.detecting = nil
+  s.vcs.vcs = nil
 
   local vcs = repo.detect_vcs(bufnr)
-  vim.b[bufnr].vcsigns_detecting = false
+  s.vcs.detecting = false
   if not vcs then
     util.verbose "No VCS detected"
     return
   end
   util.verbose("Detected VCS " .. vcs.name)
-  vim.b[bufnr].vcsigns_vcs = vcs
+  s.vcs.vcs = vcs
 
   _set_buflocal_autocmds(bufnr)
 end
···
 --- Start VCSigns for the given buffer, but skip if detection was already done.
 ---@param bufnr integer The buffer number.
 function M.start_if_needed(bufnr)
-  if vim.b[bufnr].vcsigns_vcs == nil then
+  if state.get(bufnr).vcs.vcs == nil then
     M.start(bufnr)
   end
 end
···
 
   -- Clear state.
   state.clear(bufnr)
-
-  -- Clear buffer-local variables.
-  vim.b[bufnr].vcsigns_detecting = nil
-  vim.b[bufnr].vcsigns_vcs = nil
 end
 
 local last_target_notification = nil
···
     return
   end
   local lnum = vim.fn.line "."
-  local hunks = state.get(bufnr).hunks
+  local hunks = state.get(bufnr).diff.hunks
   local hunk = forward and hunkops.next_hunk(lnum, hunks, count)
     or hunkops.prev_hunk(lnum, hunks, count)
   if hunk then
···
 ---@param range integer[] The range of lines to consider for the hunks.
 ---@return Hunk[] Hunks in the specified range.
 local function _hunks_in_range(bufnr, range)
-  local hunks = state.get(bufnr).hunks
+  local hunks = state.get(bufnr).diff.hunks
   ---@type Hunk[]
   local hunks_in_range = {}
   for _, hunk in ipairs(hunks) do

lua/vcsigns/fold.lua

···
 ---@param lnum integer
 function M.fold_expression(lnum)
   local bufnr = vim.api.nvim_get_current_buf()
-  local hunks = state.get(bufnr).hunks
+  local hunks = state.get(bufnr).diff.hunks
   if hunks == nil then
     return 0
   end

lua/vcsigns/info.lua

···
 local M = {}
 
+local state = require "vcsigns.state"
+
 function M.lualine_module()
   return {
     "diff",
···
       return vim.b.vcsigns_stats
     end,
     on_click = function()
+      local bufnr = vim.api.nvim_get_current_buf()
       local lines = {}
-      lines[#lines + 1] = vim.b.vcsigns_vcs and vim.b.vcsigns_vcs.name
-        or "No vcs detected"
+      local vcs = state.get(bufnr).vcs.vcs
+      lines[#lines + 1] = vcs and vcs.name or "No vcs detected"
       if vim.b.vcsigns_resolved_rename then
         lines[#lines + 1] = "File rename detected:"
         lines[#lines + 1] = string.format(

lua/vcsigns/state.lua

···
 local M = {}
 
+---@class BufferState
+---@field diff DiffState
+---@field vcs VcsState
+
 ---@class DiffState
 ---@field hunks Hunk[]
 ---@field old_contents string
 ---@field last_update integer
 ---@field hunks_changedtick integer
 
----@type table<integer, DiffState>
+---@class VcsState
+---@field vcs Vcs|nil
+---@field detecting boolean|nil
+
+---@type table<integer, BufferState>
 local buffers = {}
 
 ---@param bufnr integer
----@return DiffState
+---@return BufferState
 function M.get(bufnr)
   if bufnr == 0 then
     bufnr = vim.api.nvim_get_current_buf()
   end
   if not buffers[bufnr] then
     buffers[bufnr] = {
-      hunks = {},
-      old_contents = "",
-      last_update = 0,
-      hunks_changedtick = 0,
+      diff = {
+        hunks = {},
+        old_contents = "",
+        last_update = 0,
+        hunks_changedtick = 0,
+      },
+      vcs = {
+        vcs = nil,
+        detecting = nil,
+      },
     }
   end
   return buffers[bufnr]

lua/vcsigns/textobj.lua

···
 
 function M.select_hunk(bufnr)
   local lnum = vim.fn.line "."
-  local hunks = state.get(bufnr).hunks
+  local hunks = state.get(bufnr).diff.hunks
   local hunk = hunkops.cur_hunk(lnum, hunks)
   if not hunk then
     vim.notify(

lua/vcsigns/updates.lua

···
   local buffer_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
   local new_contents = table.concat(buffer_lines, "\n") .. "\n"
   local s = state.get(bufnr)
-  local old_contents = s.old_contents
+  local old_contents = s.diff.old_contents
 
   if not old_contents then
     util.verbose "No old contents available, skipping diff."
···
   end
 
   local hunks = diff.compute_diff(old_contents, new_contents)
-  s.hunks = hunks
+  s.diff.hunks = hunks
   sign.add_signs(bufnr, hunks)
 
   if vim.b[bufnr].vcsigns_show_hunk_diffs then
···
       return
     end
     local s = state.get(bufnr)
-    local last = s.last_update
+    local last = s.diff.last_update
     if start_time <= last then
       util.verbose "Skipping updating old file, we already have a newer update."
       return
     end
-    s.old_contents = old_contents
-    s.last_update = start_time
-    s.hunks_changedtick = vim.b[bufnr].changedtick
+    s.diff.old_contents = old_contents
+    s.diff.last_update = start_time
+    s.diff.hunks_changedtick = vim.b[bufnr].changedtick
     cb(bufnr)
   end)
 end
···
 ---@param bufnr integer The buffer number.
 ---@return Vcs|nil The VCS object if ready, nil otherwise.
 local function _get_vcs_if_ready(bufnr)
-  local detecting = vim.b[bufnr].vcsigns_detecting
+  local vcs_state = state.get(bufnr).vcs
+  local detecting = vcs_state.detecting
   if detecting == nil then
     util.verbose "Buffer not initialized yet."
   end
···
     util.verbose "Busy detecting, skipping."
     return
   end
-  return vim.b[bufnr].vcsigns_vcs
+  return vcs_state.vcs
 end
 
 --- Expensive update including vcs querying for file contents.