jiriks74/presence.nvim
1
0
Fork 0
mirror of https://github.com/jiriks74/presence.nvim synced 2024-12-28 11:02:34 +01:00
Code Issues Releases Activity Actions

Support peer-to-peer workspace state management

Browse source 
- Add sync logic to manage multi-client runtime state
- Debounce and set activity on TextChanged events
- Update timestamp to be workspace-specific
- Set activity on an open nvim instance upon a VimLeave event
This commit is contained in:
Andrew Kwon 2021-03-18 18:32:06 -07:00
parent a2f6550177
commit a325d154fc
5 changed files with 490 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
README.md
View file

@ -36,6 +36,7 @@ Presence = require("presence"):setup({
main_image = "neovim", -- Main image display (either "neovim" or "file")
client_id = "793271441293967371", -- Use your own Discord application client id (not recommended)
log_level = nil, -- Log messages at or above this level (one of the following: "debug", "info", "warn", "error")
debounce_timeout = 15, -- Number of seconds to debounce TextChanged events (or calls to `:lua Presence:update(<buf>, true)`)
})
```
@ -49,14 +50,18 @@ let g:presence_neovim_image_text = "The One True Text Editor"
let g:presence_main_image = "neovim"
let g:presence_client_id = "793271441293967371"
let g:presence_log_level
let g:presence_debounce_timeout = 15
```
## Contributing
Pull requests are very welcome! Here some open todo items:
Pull requests are very welcome, feel free to open an issue! Here some open todo items:
- [x] Manage workspace state across multiple nvim instances (e.g. tmux)
- [x] Set activity on other autocommands (`TextChanged`, `VimLeavePre`)
- [ ] Set idle activity (track using `CursorMoved`)
- [ ] Use named pipes to support Windows
- [ ] Expose file assets table as a configurable option
- [ ] Manage activity properly in buffers in windows and tabs
- [ ] Retry connection after initial setup or a closed pipe (i.e. after quitting Discord app)
- [ ] Attempt to connect to a range of pipes from `discord-ipc-0` to `discord-ipc-9` (see [note](https://github.com/discord/discord-rpc/blob/master/documentation/hard-mode.md#notes))
- [ ] Set activity on other autocommands (`:h events`)
Discord asset additions and changes are also welcome! Supported file types can be found in [file_assets.lua](lua/presence/file_assets.lua) and their assets can be found [in this folder](https://www.dropbox.com/sh/j8913f0gav3toeh/AADxjn0NuTprGFtv3Il1Pqz-a?dl=0).

2
autoload/presence.vim
View file

@ -4,6 +4,8 @@ function presence#SetAutoCmds()
autocmd!
if exists("g:presence_auto_update") && g:presence_auto_update
autocmd BufRead * lua package.loaded.presence:update()
autocmd TextChanged * lua package.loaded.presence:update(nil, true)
autocmd VimLeavePre * lua package.loaded.presence:unregister_self()
endif
augroup END
endfunction

140
lua/deps/serpent.lua Normal file
View file

@ -0,0 +1,140 @@
local n, v = "serpent", "0.302" -- (C) 2012-18 Paul Kulchenko; MIT License
local c, d = "Paul Kulchenko", "Lua serializer and pretty printer"
local snum = {[tostring(1/0)]='1/0 --[[math.huge]]',[tostring(-1/0)]='-1/0 --[[-math.huge]]',[tostring(0/0)]='0/0'}
local badtype = {thread = true, userdata = true, cdata = true}
local getmetatable = debug and debug.getmetatable or getmetatable
local pairs = function(t) return next, t end -- avoid using __pairs in Lua 5.2+
local keyword, globals, G = {}, {}, (_G or _ENV)
for _,k in ipairs({'and', 'break', 'do', 'else', 'elseif', 'end', 'false',
'for', 'function', 'goto', 'if', 'in', 'local', 'nil', 'not', 'or', 'repeat',
'return', 'then', 'true', 'until', 'while'}) do keyword[k] = true end
for k,v in pairs(G) do globals[v] = k end -- build func to name mapping
for _,g in ipairs({'coroutine', 'debug', 'io', 'math', 'string', 'table', 'os'}) do
for k,v in pairs(type(G[g]) == 'table' and G[g] or {}) do globals[v] = g..'.'..k end end
local function s(t, opts)
local name, indent, fatal, maxnum = opts.name, opts.indent, opts.fatal, opts.maxnum
local sparse, custom, huge = opts.sparse, opts.custom, not opts.nohuge
local space, maxl = (opts.compact and '' or ' '), (opts.maxlevel or math.huge)
local maxlen, metatostring = tonumber(opts.maxlength), opts.metatostring
local iname, comm = '_'..(name or ''), opts.comment and (tonumber(opts.comment) or math.huge)
local numformat = opts.numformat or "%.17g"
local seen, sref, syms, symn = {}, {'local '..iname..'={}'}, {}, 0
local function gensym(val) return '_'..(tostring(tostring(val)):gsub("[^%w]",""):gsub("(%d%w+)",
-- tostring(val) is needed because __tostring may return a non-string value
function(s) if not syms[s] then symn = symn+1; syms[s] = symn end return tostring(syms[s]) end)) end
local function safestr(s) return type(s) == "number" and tostring(huge and snum[tostring(s)] or numformat:format(s))
or type(s) ~= "string" and tostring(s) -- escape NEWLINE/010 and EOF/026
or ("%q"):format(s):gsub("\010","n"):gsub("\026","\\026") end
local function comment(s,l) return comm and (l or 0) < comm and ' --[['..select(2, pcall(tostring, s))..']]' or '' end
local function globerr(s,l) return globals[s] and globals[s]..comment(s,l) or not fatal
and safestr(select(2, pcall(tostring, s))) or error("Can't serialize "..tostring(s)) end
local function safename(path, name) -- generates foo.bar, foo[3], or foo['b a r']
local n = name == nil and '' or name
local plain = type(n) == "string" and n:match("^[%l%u_][%w_]*$") and not keyword[n]
local safe = plain and n or '['..safestr(n)..']'
return (path or '')..(plain and path and '.' or '')..safe, safe end
local alphanumsort = type(opts.sortkeys) == 'function' and opts.sortkeys or function(k, o, n) -- k=keys, o=originaltable, n=padding
local maxn, to = tonumber(n) or 12, {number = 'a', string = 'b'}
local function padnum(d) return ("%0"..tostring(maxn).."d"):format(tonumber(d)) end
table.sort(k, function(a,b)
-- sort numeric keys first: k[key] is not nil for numerical keys
return (k[a] ~= nil and 0 or to[type(a)] or 'z')..(tostring(a):gsub("%d+",padnum))
< (k[b] ~= nil and 0 or to[type(b)] or 'z')..(tostring(b):gsub("%d+",padnum)) end) end
local function val2str(t, name, indent, insref, path, plainindex, level)
local ttype, level, mt = type(t), (level or 0), getmetatable(t)
local spath, sname = safename(path, name)
local tag = plainindex and
((type(name) == "number") and '' or name..space..'='..space) or
(name ~= nil and sname..space..'='..space or '')
if seen[t] then -- already seen this element
sref[#sref+1] = spath..space..'='..space..seen[t]
return tag..'nil'..comment('ref', level) end
-- protect from those cases where __tostring may fail
if type(mt) == 'table' and metatostring ~= false then
local to, tr = pcall(function() return mt.__tostring(t) end)
local so, sr = pcall(function() return mt.__serialize(t) end)
if (to or so) then -- knows how to serialize itself
seen[t] = insref or spath
t = so and sr or tr
ttype = type(t)
end -- new value falls through to be serialized
end
if ttype == "table" then
if level >= maxl then return tag..'{}'..comment('maxlvl', level) end
seen[t] = insref or spath
if next(t) == nil then return tag..'{}'..comment(t, level) end -- table empty
if maxlen and maxlen < 0 then return tag..'{}'..comment('maxlen', level) end
local maxn, o, out = math.min(#t, maxnum or #t), {}, {}
for key = 1, maxn do o[key] = key end
if not maxnum or #o < maxnum then
local n = #o -- n = n + 1; o[n] is much faster than o[#o+1] on large tables
for key in pairs(t) do if o[key] ~= key then n = n + 1; o[n] = key end end end
if maxnum and #o > maxnum then o[maxnum+1] = nil end
if opts.sortkeys and #o > maxn then alphanumsort(o, t, opts.sortkeys) end
local sparse = sparse and #o > maxn -- disable sparsness if only numeric keys (shorter output)
for n, key in ipairs(o) do
local value, ktype, plainindex = t[key], type(key), n <= maxn and not sparse
if opts.valignore and opts.valignore[value] -- skip ignored values; do nothing
or opts.keyallow and not opts.keyallow[key]
or opts.keyignore and opts.keyignore[key]
or opts.valtypeignore and opts.valtypeignore[type(value)] -- skipping ignored value types
or sparse and value == nil then -- skipping nils; do nothing
elseif ktype == 'table' or ktype == 'function' or badtype[ktype] then
if not seen[key] and not globals[key] then
sref[#sref+1] = 'placeholder'
local sname = safename(iname, gensym(key)) -- iname is table for local variables
sref[#sref] = val2str(key,sname,indent,sname,iname,true) end
sref[#sref+1] = 'placeholder'
local path = seen[t]..'['..tostring(seen[key] or globals[key] or gensym(key))..']'
sref[#sref] = path..space..'='..space..tostring(seen[value] or val2str(value,nil,indent,path))
else
out[#out+1] = val2str(value,key,indent,nil,seen[t],plainindex,level+1)
if maxlen then
maxlen = maxlen - #out[#out]
if maxlen < 0 then break end
end
end
end
local prefix = string.rep(indent or '', level)
local head = indent and '{\n'..prefix..indent or '{'
local body = table.concat(out, ','..(indent and '\n'..prefix..indent or space))
local tail = indent and "\n"..prefix..'}' or '}'
return (custom and custom(tag,head,body,tail,level) or tag..head..body..tail)..comment(t, level)
elseif badtype[ttype] then
seen[t] = insref or spath
return tag..globerr(t, level)
elseif ttype == 'function' then
seen[t] = insref or spath
if opts.nocode then return tag.."function() --[[..skipped..]] end"..comment(t, level) end
local ok, res = pcall(string.dump, t)
local func = ok and "((loadstring or load)("..safestr(res)..",'@serialized'))"..comment(t, level)
return tag..(func or globerr(t, level))
else return tag..safestr(t) end -- handle all other types
end
local sepr = indent and "\n" or ";"..space
local body = val2str(t, name, indent) -- this call also populates sref
local tail = #sref>1 and table.concat(sref, sepr)..sepr or ''
local warn = opts.comment and #sref>1 and space.."--[[incomplete output with shared/self-references skipped]]" or ''
return not name and body..warn or "do local "..body..sepr..tail.."return "..name..sepr.."end"
end
local function deserialize(data, opts)
local env = (opts and opts.safe == false) and G
or setmetatable({}, {
__index = function(t,k) return t end,
__call = function(t,...) error("cannot call functions") end
})
local f, res = (loadstring or load)('return '..data, nil, nil, env)
if not f then f, res = (loadstring or load)(data, nil, nil, env) end
if not f then return f, res end
if setfenv then setfenv(f, env) end
return pcall(f)
end
local function merge(a, b) if b then for k,v in pairs(b) do a[k] = v end end; return a; end
return { _NAME = n, _COPYRIGHT = c, _DESCRIPTION = d, _VERSION = v, serialize = s,
load = deserialize,
dump = function(a, opts) return s(a, merge({name = '_', compact = true, sparse = true}, opts)) end,
line = function(a, opts) return s(a, merge({sortkeys = true, comment = true}, opts)) end,
block = function(a, opts) return s(a, merge({indent = ' ', sortkeys = true, comment = true}, opts)) end }

8
lua/presence/discord.lua
View file

@ -149,13 +149,19 @@ function Discord:set_activity(activity, on_response)
self:call(self.opcodes.frame, payload, on_response)
end
function Discord.generate_uuid()
function Discord.generate_uuid(seed)
local index = 0
local template ="xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
local uuid = template:gsub("[xy]", function(char)
-- Increment an index to seed per char
index = index + 1
math.randomseed((seed or os.clock()) / index)
local n = char == "x"
and math.random(0, 0xf)
or math.random(8, 0xb)
return string.format("%x", n)
end)

378
lua/presence/init.lua
View file

@ -1,7 +1,63 @@
--------------------------------------------------
-- ____ --
-- / __ \________ ________ ____ ________ --
-- / /_/ / ___/ _ \/ ___/ _ \/ __ \/ ___/ _ \ --
-- / ____/ / / __(__ ) __/ / / / /__/ __/ --
-- /_/ /_/ \___/____/\___/_/ /_/\___/\___/ --
-- --
-- Discord Rich Presence plugin for Neovim. --
--------------------------------------------------
-- Nvim peer-to-peer runtime state shape example:
--
-- Presence = {
-- id = "ee1fc18f-2c81-4b88-b92e-cb801fbe8d85",
-- workspace = "/Users/user/Code/presence.nvim",
-- socket = "/var/folders/mm/8qfxwcdn29s8d_rzmj7bqxb40000gn/T/nvim9pEtTD/0",
--
-- -- Last activity set by current client or any peer instance
-- last_activity = {
-- file = "/Users/user/Code/presence.nvim/README.md",
-- workspace = "/Users/user/Code/presence.nvim",
-- },
--
-- -- Other remote Neovim instances (peers)
-- peers = {
-- ["dd5eeafe-8d0d-44d7-9850-45d3884be1a0"] = {
-- workspace = "/Users/user/Code/presence.nvim",
-- socket = "/var/folders/mm/8qfxwcdn29s8d_rzmj7bqxb40000gn/T/nvim9pEtTD/0",
-- },
-- ["346750e6-c416-44ff-98f3-eb44ea2ef15d"] = {
-- workspace = "/Users/user/Code/presence.nvim",
-- socket = "/var/folders/mm/8qfxwcdn29s8d_rzmj7bqxb40000gn/T/nvim09n664/0",
-- }
-- },
--
-- -- Workspace states across all peers
-- workspaces = {
-- ["/Users/user/Code/dotfiles"] = {
-- started_at = 1616033505,
-- updated_at = 1616033505
-- },
-- ["/Users/user/Code/presence.nvim"] = {
-- started_at = 1616033442,
-- updated_at = 1616033523
-- },
-- },
--
-- ... other methods and member variables
-- }
local Presence = {}
Presence.is_authorized = false
Presence.is_connected = false
Presence.last_activity = {}
Presence.peers = {}
Presence.socket = vim.v.servername
Presence.workspace = nil
Presence.workspaces = {}
local log = require("lib.log")
local msgpack = require("deps.msgpack")
local serpent = require("deps.serpent")
local Discord = require("presence.discord")
local file_assets = require("presence.file_assets")
@ -12,6 +68,7 @@ function Presence:setup(options)
-- Initialize logger
self:set_option("log_level", nil, false)
self.log = log:init({ level = options.log_level })
self.log:debug("Setting up plugin...")
-- Use the default or user-defined client id if provided
if options.client_id then
@ -24,8 +81,19 @@ function Presence:setup(options)
self:set_option("workspace_text", "Working on %s")
self:set_option("neovim_image_text", "The One True Text Editor")
self:set_option("client_id", "793271441293967371")
self:set_option("debounce_timeout", 15)
self.log:debug("Setting up plugin...")
-- Initialize discord RPC client
self.discord = Discord:init({
logger = self.log,
client_id = options.client_id,
ipc_path = self.get_ipc_path(),
})
-- Seed instance id using unique socket address
local seed_nums = {}
self.socket:gsub(".", function(c) table.insert(seed_nums, c:byte()) end)
self.id = self.discord.generate_uuid(tonumber(table.concat(seed_nums)) / os.clock())
-- Ensure auto-update config is reflected in its global var setting
vim.api.nvim_set_var("presence_auto_update", options.auto_update)
@ -33,21 +101,14 @@ function Presence:setup(options)
-- Set autocommands
vim.fn["presence#SetAutoCmds"]()
-- Internal state
self.is_connected = false
self.is_authorized = false
self.discord = Discord:init({
logger = self.log,
client_id = options.client_id,
ipc_path = self.get_ipc_path(),
})
self.log:info("Completed plugin setup")
-- Set global variable to indicate plugin has been set up
vim.api.nvim_set_var("presence_has_setup", 1)
-- Register self to any remote Neovim instances
self:register_self()
return self
end
@ -102,21 +163,6 @@ function Presence:cancel()
end)
end
-- Send command to cancel the presence for all other remote Neovim instances
function Presence:cancel_all_remote_instances()
self:get_nvim_socket_addrs(function(sockets)
for i = 1, #sockets do
local nvim_socket = sockets[i]
-- Skip if the nvim socket is the current instance
if nvim_socket ~= vim.v.servername then
local command = "lua package.loaded.presence:cancel()"
self:call_remote_nvim_instance(nvim_socket, command)
end
end
end)
end
-- Call a command on a remote Neovim instance at the provided IPC path
function Presence:call_remote_nvim_instance(ipc_path, command)
local remote_nvim_instance = vim.loop.new_pipe(true)
@ -128,13 +174,32 @@ function Presence:call_remote_nvim_instance(ipc_path, command)
remote_nvim_instance:write(packed, function()
self.log:debug(string.format("Wrote to remote nvim instance: %s", ipc_path))
remote_nvim_instance:shutdown()
remote_nvim_instance:close()
end)
end)
end
-- Call a Presence method on a remote instance with a given list of arguments
function Presence:call_remote_method(socket, name, args)
local command_fmt = "lua package.loaded.presence:%s(%s)"
-- Stringify the list of args
for i = 1, #args do
local arg = args[i]
if type(arg) == "string" then
args[i] = string.format([["%s"]], arg)
elseif type(arg) == "boolean" then
args[i] = string.format([["%s"]], tostring(arg))
elseif type(arg) == "table" then
-- Wrap serpent dump with function invocation to pass in the table value
args[i] = string.format("(function() %s end)()", serpent.dump(arg))
end
end
local arglist = table.concat(args or {}, ",")
local command = string.format(command_fmt, name, arglist)
self:call_remote_nvim_instance(socket, command)
end
function Presence:connect(on_done)
self.log:debug("Connecting to Discord...")
@ -224,7 +289,7 @@ function Presence:get_project_name(file_path)
return nil
end
return self.get_filename(project_path)
return self.get_filename(project_path), project_path
end
-- Get the name of the parent directory for the given path
@ -245,7 +310,13 @@ end
-- Get all active local nvim unix domain socket addresses
function Presence:get_nvim_socket_addrs(on_done)
-- TODO: Find a better way to get paths of remote Neovim sockets lol
local cmd = [[netstat -u | grep --color=never "nvim.*/0" | awk -F "[ :]+" '{print $9}' | uniq]]
local cmd = table.concat({
"netstat -u",
[[grep --color=never "nvim.*/0"]],
[[awk -F "[ :]+" '{print $9}']],
"sort",
"uniq",
}, "|")
local sockets = {}
local function handle_data(_, data)
@ -253,7 +324,7 @@ function Presence:get_nvim_socket_addrs(on_done)
for i = 1, #data do
local socket = data[i]
if socket ~= "" and socket ~= vim.v.servername then
if socket ~= "" and socket ~= self.socket then
table.insert(sockets, socket)
end
end
@ -303,11 +374,15 @@ function Presence.discord_event(on_ready)
end
-- Update Rich Presence for the provided vim buffer
function Presence:update_for_buffer(buffer)
self.log:debug(string.format("Setting activity for %s...", buffer))
function Presence:update_for_buffer(buffer, should_debounce)
if should_debounce and self.last_activity.file == buffer then
self.log:debug(string.format("Activity already set for %s, skipping...", buffer))
return
end
-- Send command to cancel presence for all remote Neovim instances
self:cancel_all_remote_instances()
local activity_set_at = os.time()
self.log:debug(string.format("Setting activity for %s...", buffer))
-- Parse vim buffer
local filename = self.get_filename(buffer)
@ -326,9 +401,6 @@ function Presence:update_for_buffer(buffer)
local file_text = description or name
local neovim_image_text = self.options.neovim_image_text
-- TODO: Update timestamp to be workspace-specific
local started_at = os.time()
local use_file_as_main_image = self.options.main_image == "file"
local assets = {
large_image = use_file_as_main_image and asset_key or "neovim",
@ -346,12 +418,12 @@ function Presence:update_for_buffer(buffer)
state = editing_text,
assets = assets,
timestamps = {
start = started_at
start = activity_set_at,
},
}
local workspace_text = self.options.workspace_text
local project_name = self:get_project_name(parent_dirpath)
local project_name, project_path = self:get_project_name(parent_dirpath)
-- Include project details if available
if project_name then
@ -360,9 +432,35 @@ function Presence:update_for_buffer(buffer)
activity.details = type(workspace_text) == "function"
and workspace_text(project_name, buffer)
or string.format(workspace_text, project_name)
self.workspace = project_path
self.last_activity = {
file = buffer,
set_at = activity_set_at,
workspace = project_path,
}
if self.workspaces[project_path] then
self.workspaces[project_path].updated_at = activity_set_at
activity.timestamps = {
start = self.workspaces[project_path].started_at,
}
else
self.workspaces[project_path] = {
started_at = activity_set_at,
updated_at = activity_set_at,
}
end
else
self.log:debug("No project detected")
self.workspace = nil
self.last_activity = {
file = buffer,
set_at = activity_set_at,
workspace = nil,
}
-- When no project is detected, set custom workspace text if:
-- * The custom function returns custom workspace text
-- * The configured workspace text does not contain a directive
@ -376,6 +474,9 @@ function Presence:update_for_buffer(buffer)
end
end
-- Sync activity to all peers
self:sync_self_activity()
self.discord:set_activity(activity, function(err)
if err then
self.log:error("Failed to set activity in Discord: "..err)
@ -387,16 +488,205 @@ function Presence:update_for_buffer(buffer)
end
-- Update Rich Presence for the current or provided vim buffer for an authorized connection
Presence.update = Presence.discord_event(function(self, buffer)
Presence.update = Presence.discord_event(function(self, buffer, should_debounce)
-- Default update to not debounce by default
if should_debounce == nil then should_debounce = false end
-- Debounce Rich Presence updates (default to 15 seconds):
-- https://discord.com/developers/docs/rich-presence/how-to#updating-presence
local last_updated_at = self.last_activity.set_at
local debounce_timeout = self.options.debounce_timeout
local should_skip = should_debounce and debounce_timeout and
last_updated_at and os.time() - last_updated_at <= debounce_timeout
if should_skip then
local message_fmt = "Last activity sent was within %d seconds ago, skipping..."
self.log:debug(string.format(message_fmt, debounce_timeout))
return
end
if buffer then
self:update_for_buffer(buffer)
self:update_for_buffer(buffer, should_debounce)
else
self.get_current_buffer(function(current_buffer)
self:update_for_buffer(current_buffer)
self:update_for_buffer(current_buffer, should_debounce)
end)
end
end)
-- Register some remote peer
function Presence:register_peer(id, socket)
self.log:debug(string.format("Registering peer %s...", id))
self.peers[id] = {
socket = socket,
workspace = nil,
}
self.log:info(string.format("Registered peer %s", id))
end
-- Unregister some remote peer
function Presence:unregister_peer(id, peer)
self.log:debug(string.format("Unregistering peer %s... %s", id, vim.inspect(peer)))
-- Remove workspace if no other peers share the same workspace
-- Initialize to remove if the workspace differs from the local workspace, check peers below
local should_remove_workspace = peer.workspace ~= self.workspace
local peers = {}
for peer_id, peer_data in pairs(self.peers) do
-- Omit peer from peers list
if peer_id ~= id then
peers[peer_id] = peer_data
-- Should not remove workspace if another peer shares the workspace
if should_remove_workspace and peer.workspace == peer_data.workspace then
should_remove_workspace = false
end
end
end
self.peers = peers
-- Update workspaces if necessary
local workspaces = {}
if should_remove_workspace then
self.log:debug(string.format("Should remove workspace %s", peer.workspace))
for workspace, data in pairs(self.workspaces) do
if workspace ~= peer.workspace then
workspaces[workspace] = data
end
end
self.workspaces = workspaces
end
self.log:info(string.format("Unregistered peer %s", id))
end
-- Unregister some remote peer and set activity
function Presence:unregister_peer_and_set_activity(id, peer)
self:unregister_peer(id, peer)
self:update()
end
-- Register a remote peer and sync its data
function Presence:register_and_sync_peer(id, socket)
self:register_peer(id, socket)
self.log:debug("Syncing data with newly registered peer...")
-- Initialize the remote peer's list including self
local peers = {
[self.id] = {
socket = self.socket,
workspace = self.workspace,
}
}
for peer_id, peer in pairs(self.peers) do
if peer_id ~= id then
peers[peer_id] = peer
end
end
self:call_remote_method(socket, "sync_self", {{
last_activity = self.last_activity,
peers = peers,
workspaces = self.workspaces,
}})
end
-- Register self to any remote Neovim instances
-- Simply emits to all nvim socket addresses as we have not yet been synced with peer list
function Presence:register_self()
self:get_nvim_socket_addrs(function(sockets)
if #sockets == 0 then
self.log:debug("No other remote nvim instances")
return
end
self.log:debug(string.format("Registering as a new peer to %d instance(s)...", #sockets))
-- Register and sync state with one of the sockets
self:call_remote_method(sockets[1], "register_and_sync_peer", { self.id, self.socket })
if #sockets == 1 then
return
end
for i = 2, #sockets do
self:call_remote_method(sockets[i], "register_peer", { self.id, self.socket })
end
end)
end
-- Unregister self to all peers
function Presence:unregister_self()
local self_as_peer = {
socket = self.socket,
workspace = self.workspace,
}
local i = 1
for id, peer in pairs(self.peers) do
if self.options.auto_update and i == 1 then
self.log:debug(string.format("Unregistering self and setting activity for peer %s...", id))
self:call_remote_method(peer.socket, "unregister_peer_and_set_activity", { self.id, self_as_peer })
else
self.log:debug(string.format("Unregistering self to peer %s...", id))
self:call_remote_method(peer.socket, "unregister_peer", { self.id, self_as_peer })
end
i = i + 1
end
end
-- Sync self with data from a remote peer
function Presence:sync_self(data)
self.log:debug(string.format("Syncing data from remote peer...", vim.inspect(data)))
for key, value in pairs(data) do
self[key] = value
end
self.log:info("Synced runtime data from remote peer")
end
-- Sync activity set by self to all peers
function Presence:sync_self_activity()
local self_as_peer = {
socket = self.socket,
workspace = self.workspace,
}
for id, peer in pairs(self.peers) do
self.log:debug(string.format("Syncing activity to peer %s...", id))
local peers = { [self.id] = self_as_peer }
for peer_id, peer_data in pairs(self.peers) do
if peer_id ~= id then
peers[peer_id] = {
socket = peer_data.socket,
workspace = peer_data.workspace,
}
end
end
self:call_remote_method(peer.socket, "sync_peer_activity", {{
last_activity = self.last_activity,
peers = peers,
workspaces = self.workspaces,
}})
end
end
-- Sync activity set by peer
function Presence:sync_peer_activity(data)
self.log:debug(string.format("Syncing peer activity %s...", vim.inspect(data)))
self:cancel()
self:sync_self(data)
end
function Presence:stop()
self.log:debug("Disconnecting from Discord...")
self.discord:disconnect(function()