hexedtech/codemp-sublime
3
0
Fork 0
mirror of https://github.com/hexedtech/codemp-sublime.git synced 2024-12-04 20:04:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Major code refactor, to support v0.6 codemp. Should work, minor details to go through, like internal buffer mappings.

Browse source 
Former-commit-id: 3602917d52fd33e9eb77fb5a9fe9a87010e94a03
This commit is contained in:
Camillo Schenone 2024-02-21 23:59:49 +01:00
parent 6831c07a64
commit a986aa18c6
3 changed files with 845 additions and 577 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
Codemp.sublime-commands
View file

@ -38,12 +38,19 @@
}
},
{
"caption": "Codemp: Join",
"caption": "Codemp: Join Workspace",
"command": "codemp_join",
"arg": {
// 'server_buffer' : 'test'
},
},
{
"caption": "Codemp: Join buffer",
"command": "codemp_attach",
"arg": {
// 'server_buffer' : 'test'
},
},
{
"caption": "Codemp: Disconnect Buffer",
"command": "codemp_disconnect_buffer",

556
plugin.py
View file

@ -2,24 +2,16 @@ import sublime
import sublime_plugin
# import Codemp.codemp_client as codemp
from Codemp.src.codemp_client import *
# we import the PyTextChange type to be able to access its @classmethods: from_diff and index_to_rowcol
# PyTextChange instances are not meant to be created from python, but only received immutable from codemp.
from Codemp.bindings.codemp_client import PyTextChange
import Codemp.ext.sublime_asyncio as sublime_asyncio
import asyncio
import os
import time
from Codemp.src.codemp_client import (
VirtualClient,
status_log,
safe_listener_detach,
is_active,
)xs
# UGLYYYY, find a way to not have global variables laying around.
_tasks = []
_buffers = []
_client = None
_cursor_controller = None
_txt_change_listener = None
_exit_handler_id = None
_palette = [
"var(--redish)",
@ -40,73 +32,67 @@ _regions_colors = [
"region.cyanish",
"region.bluish",
"region.purplish",
"region.pinkish"
"region.pinkish",
]
## Initialisation and Deinitialisation
# Initialisation and Deinitialisation
##############################################################################
async def disconnect_client():
global _client
global _cursor_controller
global _buffers
global _txt_change_listener
global _tasks
status_log("disconnecting...")
# buffers clean up after themselves after detaching
for buff in _buffers:
await buff.detach(_client)
for task in _tasks:
task.cancel()
if _cursor_controller:
await _client.leave_workspace()
if _txt_change_listener:
safe_listener_detach(_txt_change_listener)
def plugin_loaded():
global _client
global _txt_change_listener
global _exit_handler_id
_client = CodempClient() # create an empty instance of the codemp client.
_txt_change_listener = CodempClientTextChangeListener() # instantiate the listener to attach around.
# instantiate and start a global asyncio event loop.
# pass in the exit_handler coroutine that will be called upon relasing the event loop.
_exit_handler_id = sublime_asyncio.acquire(disconnect_client)
_client = VirtualClient(disconnect_client)
_txt_change_listener = CodempClientTextChangeListener()
status_log("plugin loaded")
async def disconnect_client():
global _client
global _txt_change_listener
safe_listener_detach(_txt_change_listener)
_client.tm.stop_all()
for vws in _client.workspaces:
vws.cleanup()
# fime: allow riconnections
_client = None
def plugin_unloaded():
sublime_asyncio.release(False, _exit_handler_id)
# disconnect the client.
status_log("unloading")
global _client
# releasing the runtime, runs the disconnect callback defined when acquiring the event loop.
_client.tm.release(False)
status_log("plugin unloaded")
## Utils ##
# Utils
##############################################################################
def status_log(msg):
sublime.status_message("[codemp] {}".format(msg))
print("[codemp] {}".format(msg))
def store_task(name = None):
def store_named_task(task):
global _tasks
task.set_name(name)
_tasks.append(task)
return store_named_task
def get_contents(view):
r = sublime.Region(0, view.size())
return view.substr(r)
def populate_view(view, content):
view.run_command("codemp_replace_text", {
view.run_command(
"codemp_replace_text",
{
"start": 0,
"end": view.size(),
"content": content,
"change_id": view.change_id(),
})
},
)
def get_view_from_local_path(path):
for window in sublime.windows():
@ -114,251 +100,28 @@ def get_view_from_local_path(path):
if view.file_name() == path:
return view
def rowcol_to_region(view, start, end):
a = view.text_point(start[0], start[1])
b = view.text_point(end[0], end[1])
return sublime.Region(a, b)
def get_buffer_from_buffer_id(buffer_id):
global _buffers
for b in _buffers:
if b.view.buffer_id() == buffer_id:
return b
def get_buffer_from_remote_name(remote_name):
global _buffers
for b in _buffers:
if b.remote_name == remote_name:
return b
def is_active(view):
if view.window().active_view() == view:
return True
return False
def safe_listener_detach(txt_listener):
if txt_listener.is_attached():
txt_listener.detach()
## Main logic (build coroutines to be dispatched through sublime_asyncio)
# Connection command
##############################################################################
async def connect_command(server_host, session):
global _client
status_log("Connecting to {}".format(server_host))
try:
await _client.connect(server_host)
await join_workspace(session)
except Exception as e:
sublime.error_message("Could not connect:\n Make sure the server is up.")
return
# Workspace and cursor (attaching, sending and receiving)
##############################################################################
async def join_workspace(session):
global _client
global _cursor_controller
status_log("Joining workspace: {}".format(session))
_cursor_controller = await _client.join(session)
sublime_asyncio.dispatch(
move_cursor(_cursor_controller),
store_task("move-cursor"))
async def move_cursor(cursor_controller):
global _regions_colors
global _palette
status_log("spinning up cursor worker...")
# TODO: make the matching user/color more solid. now all users have one color cursor.
# Maybe make all cursors the same color and only use annotations as a discriminant.
# idea: use a user id hash map that maps to a color.
try:
while cursor_event := await cursor_controller.recv():
buffer = get_buffer_from_remote_name(cursor_event.buffer)
if not buffer:
status_log("Received a cursor event for an unknown buffer: {}".format(cursor_event.buffer))
continue
reg = rowcol_to_region(buffer.view, cursor_event.start, cursor_event.end)
reg_flags = sublime.RegionFlags.DRAW_EMPTY # show cursors.
user_hash = hash(cursor_event.user)
buffer.view.add_regions(
"codemp-cursors-{}".format(user_hash),
[reg],
flags = reg_flags,
scope=_regions_colors[user_hash % len(_regions_colors)],
annotations = [cursor_event.user],
annotation_color=_palette[user_hash % len(_palette)]
)
except asyncio.CancelledError:
status_log("cursor worker stopped...")
def send_cursor(view):
global _cursor_controller
buffer_name = get_buffer_from_buffer_id(view.buffer_id()).remote_name
region = view.sel()[0] # TODO: only the last placed cursor/selection.
start = view.rowcol(region.begin()) #only counts UTF8 chars
end = view.rowcol(region.end())
_cursor_controller.send(buffer_name, start, end)
# Buffer Controller (managing text modifications)
##############################################################################
# This class is used as an abstraction between the local buffers (sublime side) and the
# remote buffers (codemp side), to handle the syncronicity.
class CodempSublimeBuffer():
def __init__(self, view, remote_name):
self.view = view
self.remote_name = remote_name
self.worker_task_name = "buffer-worker-{}".format(self.remote_name)
async def attach(self, client):
global _txt_change_listener
global _buffers
status_log("attaching local buffer '{}' to '{}'".format(self.view.file_name(), self.remote_name))
# attach to the matching codemp buffer
self.controller = await client.attach(self.remote_name)
# if the view is already active calling focus_view() will not trigger the on_activate()
if is_active(self.view):
status_log("\tattaching text listener...")
safe_listener_detach(_txt_change_listener)
_txt_change_listener.attach(self.view.buffer())
else:
self.view.window().focus_view(self.view)
# start the buffer worker that waits for text_changes in the worker thread
sublime_asyncio.dispatch(self.apply_buffer_change(), store_task(self.worker_task_name))
_buffers.append(self)
# mark all views associated with the buffer as being connected to codemp
for v in self.view.buffer().views():
v.set_status("z_codemp_buffer", "[Codemp]")
v.settings()["codemp_buffer"] = True
async def detach(self, client):
global _txt_change_listener
global _tasks
global _buffers
status_log("detaching buffer '{}' ({})".format(self.remote_name, self.view.file_name()))
if is_active(self.view):
safe_listener_detach(_txt_change_listener)
await client.disconnect_buffer(self.remote_name)
# take down the worker task
for task in _tasks:
if task.get_name() == self.worker_task_name:
task.cancel()
_tasks.remove(task)
break
# remove yourself from the _buffers
_buffers.remove(self)
# clean up all the stuff we left around
for v in self.view.buffer().views():
del v.settings()["codemp_buffer"]
v.erase_status("z_codemp_buffer")
v.erase_regions("codemp_cursors")
async def apply_buffer_change(self):
global _txt_change_listener
status_log("spinning up '{}' buffer worker...".format(self.remote_name))
try:
while text_change := await self.controller.recv():
# In case a change arrives to a background buffer, just apply it. We are not listening on it.
# Otherwise, interrupt the listening to avoid echoing back the change just received.
if text_change.is_empty():
status_log("change is empty. skipping.")
continue
active = is_active(self.view)
if active:
safe_listener_detach(_txt_change_listener)
# we need to go through a sublime text command, since the method, view.replace
# needs an edit token, that is obtained only when calling a textcommand associated with a view.
self.view.run_command("codemp_replace_text", {
"start": text_change.start_incl,
"end": text_change.end_excl,
"content": text_change.content,
"change_id": self.view.change_id()
})
if active:
_txt_change_listener.attach(self.view.buffer())
except asyncio.CancelledError:
status_log("'{}' buffer worker stopped...".format(self.remote_name))
def send_buffer_change(self, changes):
# Sublime text on_text_changed events, can give a list of changes.
# in case of simple insertion or deletion the change is singular.
# but if we swap a string (select it and add another string in it's place) or have multiple selections
# or do an undo of some kind after the just mentioned events we receive multiple split text changes,
# e.g. select the world `hello` and replace it with `12345`: Sublime will separate it into two singular changes,
# first add `12345` in front of `hello`: `12345hello` then, delete the `hello`.
# we do not do any index checking, and trust sublime with providing the correct sequential indexing, assuming the
# changes are applied in the order they are received.
for change in changes:
region = sublime.Region(change.a.pt, change.b.pt)
status_log("sending txt change: Reg({} {}) -> '{}'".format(region.begin(), region.end(), change.str))
self.controller.send(region.begin(), region.end(), change.str)
def cleanup_tags(view):
del view.settings()["codemp_buffer"]
view.erase_status("z_codemp_buffer")
view.erase_regions("codemp_cursors")
# we call this command manually to have access to the edit token.
class CodempReplaceTextCommand(sublime_plugin.TextCommand):
def run(self, edit, start, end, content, change_id):
# we modify the region to account for any change that happened in the mean time
region = self.view.transform_region_from(sublime.Region(start, end), change_id)
self.view.replace(edit, region, content)
def tag(view):
view.set_status("z_codemp_buffer", "[Codemp]")
view.settings()["codemp_buffer"] = True
async def join_buffer_command(view, remote_name):
global _client
global _buffers
# The main workflow:
# Plugin loads and initialises an empty handle to the client
# The plugin calls connect and populates the handle with a client instance
# We use the client to authenticate and login (to a workspace) to obtain a token
# We join a workspace (either new or existing)
try:
buffer = CodempSublimeBuffer(view, remote_name)
await buffer.attach(_client)
## we should receive all contents from the server upon joining.
except Exception as e:
sublime.error_message("Could not join buffer: {}".format(e))
return
async def share_buffer_command(buffer_path, remote_name = "test"):
global _client
global _buffers
view = get_view_from_local_path(buffer_path)
contents = get_contents(view)
try:
await _client.create(remote_name, contents)
await join_buffer_command(view, remote_name)
except Exception as e:
sublime.error_message("Could not share buffer: {}".format(e))
return
async def disconnect_buffer_command(buffer):
global _client
await buffer.detach(_client)
# Listeners
##############################################################################
class CodempClientViewEventListener(sublime_plugin.ViewEventListener):
@classmethod
def is_applicable(cls, settings):
@ -369,7 +132,10 @@ class CodempClientViewEventListener(sublime_plugin.ViewEventListener):
return False
def on_selection_modified_async(self):
send_cursor(self.view)
global _client
vbuff = _client.active_workspace.get_virtual_by_local(self.view.buffer_id())
if vbuff is not None:
_client.send_cursor(vbuff)
# We only edit on one view at a time, therefore we only need one TextChangeListener
# Each time we focus a view to write on it, we first attach the listener to that buffer.
@ -384,11 +150,33 @@ class CodempClientViewEventListener(sublime_plugin.ViewEventListener):
print("view {} deactivated".format(self.view.id()))
safe_listener_detach(_txt_change_listener)
def on_text_command(self, command_name, args):
print(self.view.id(), command_name, args)
if command_name == "codemp_replace_text":
print("dry_run: detach text listener")
def on_post_text_command(self, command_name, args):
print(command_name, args)
if command_name == "codemp_replace_text":
print("dry_run: attach text listener")
# UPDATE ME
def on_pre_close(self):
global _client
buffer = get_buffer_from_buffer_id(self.view.buffer_id())
global _txt_change_listener
if is_active(self.view):
safe_listener_detach(_txt_change_listener)
vbuff = _client.active_workspace.get_virtual_by_local(self.view.buffer_id())
vbuff.cleanup()
print(list(map(lambda x: x.get_name(), _client.tm.tasks)))
task = _client.tm.cancel_and_pop(f"buffer-ctl-{vbuff.codemp_id}")
print(list(map(lambda x: x.get_name(), _client.tm.tasks)))
print(task.cancelled())
# have to run the detach logic in sync, to keep a valid reference to the view.
sublime_asyncio.sync(buffer.detach(_client))
# sublime_asyncio.sync(buffer.detach(_client))
class CodempClientTextChangeListener(sublime_plugin.TextChangeListener):
@ -401,8 +189,17 @@ class CodempClientTextChangeListener(sublime_plugin.TextChangeListener):
# lets make this blocking :D
# def on_text_changed_async(self, changes):
def on_text_changed(self, changes):
subl_buffer = get_buffer_from_buffer_id(self.buffer.id())
subl_buffer.send_buffer_change(changes)
global _client
if (
self.buffer.primary_view()
.settings()
.get("codemp_ignore_next_on_modified_text_event", None)
):
status_log("ignoring echoing back the change.")
self.view.settings()["codemp_ignore_next_on_modified_text_event"] = False
return
vbuff = _client.active_workspace.get_virtual_by_local(self.buffer.id())
_client.send_buffer_change(changes, vbuff)
# Commands:
@ -416,106 +213,138 @@ class CodempClientTextChangeListener(sublime_plugin.TextChangeListener):
# Connect Command
#############################################################################
class CodempConnectCommand(sublime_plugin.WindowCommand):
def run(self, server_host, session):
sublime_asyncio.dispatch(connect_command(server_host, session))
def run(self, server_host):
global _client
sublime_asyncio.dispatch(_client.connect(server_host))
def input(self, args):
if 'server_host' not in args:
if "server_host" not in args:
return ServerHostInputHandler()
def input_description(self):
return 'Server host:'
return "Server host:"
class ServerHostInputHandler(sublime_plugin.TextInputHandler):
def initial_text(self):
return "http://127.0.0.1:50051"
def next_input(self, args):
if 'workspace' not in args:
return CodempWorkspaceInputHandler()
class CodempWorkspaceInputHandler(sublime_plugin.TextInputHandler):
def name(self):
return 'session'
def initial_text(self):
return "default"
# Join Command
# Join Workspace Command
#############################################################################
class CodempJoinCommand(sublime_plugin.WindowCommand):
def run(self, server_buffer):
view = self.window.new_file(flags=sublime.NewFileFlags.TRANSIENT)
sublime_asyncio.dispatch(join_buffer_command(view, server_buffer))
def run(self, workspace_id):
global _client
sublime_asyncio.dispatch(_client.join_workspace(workspace_id))
def input_description(self):
return 'Join Buffer:'
return "Join Workspace:"
def input(self, args):
if 'server_buffer' not in args:
return ServerBufferInputHandler()
if "workspace_id" not in args:
return WorkspaceIdInputHandler()
class ServerBufferInputHandler(sublime_plugin.TextInputHandler):
class WorkspaceIdInputHandler(sublime_plugin.TextInputHandler):
def initial_text(self):
return "What buffer should I join?"
return "What workspace should I join?"
# Join Buffer Command
#############################################################################
class CodempAttachCommand(sublime_plugin.WindowCommand):
def run(self, buffer_id):
global _client
if _client.active_workspace is not None:
sublime_asyncio.dispatch(_client.active_workspace.attach(buffer_id))
else:
sublime.error_message(
"You haven't joined any worksapce yet. use `Codemp: Join Workspace`"
)
def input_description(self):
return "Join Buffer in workspace:"
# This is awful, fix it
def input(self, args):
global _client
if _client.active_workspace is not None:
if "buffer_id" not in args:
existing_buffers = _client.active_workspace.handle.filetree()
if len(existing_buffers) == 0:
return BufferIdInputHandler()
else:
return ListBufferIdInputHandler()
else:
sublime.error_message(
"You haven't joined any worksapce yet. use `Codemp: Join Workspace`"
)
return
class BufferIdInputHandler(sublime_plugin.TextInputHandler):
def initial_text(self):
return "Create New Buffer:"
class ListBufferIdInputHandler(sublime_plugin.ListInputHandler):
def name(self):
return "buffer_id"
def list_items(self):
global _client
return _client.active_workspace.handle.filetree()
def next_input(self, args):
if "buffer_id" not in args:
return BufferIdInputHandler()
# Text Change Command
#############################################################################
# we call this command manually to have access to the edit token.
class CodempReplaceTextCommand(sublime_plugin.TextCommand):
def run(self, edit, start, end, content, change_id):
# we modify the region to account for any change that happened in the mean time
print("running the replace command, launche manually.")
region = self.view.transform_region_from(sublime.Region(start, end), change_id)
self.view.replace(edit, region, content)
# Share Command
#############################################################################
class CodempShareCommand(sublime_plugin.WindowCommand):
def run(self, sublime_buffer_path, server_id):
sublime_asyncio.dispatch(share_buffer_command(sublime_buffer_path, server_id))
# #############################################################################
# class CodempShareCommand(sublime_plugin.WindowCommand):
# def run(self, sublime_buffer_path, server_id):
# sublime_asyncio.dispatch(share_buffer_command(sublime_buffer_path, server_id))
def input(self, args):
if 'sublime_buffer' not in args:
return SublimeBufferPathInputHandler()
# def input(self, args):
# if "sublime_buffer" not in args:
# return SublimeBufferPathInputHandler()
def input_description(self):
return 'Share Buffer:'
# def input_description(self):
# return "Share Buffer:"
class SublimeBufferPathInputHandler(sublime_plugin.ListInputHandler):
def list_items(self):
ret_list = []
for window in sublime.windows():
for view in window.views():
if view.file_name():
ret_list.append(view.file_name())
# class SublimeBufferPathInputHandler(sublime_plugin.ListInputHandler):
# def list_items(self):
# ret_list = []
return ret_list
# for window in sublime.windows():
# for view in window.views():
# if view.file_name():
# ret_list.append(view.file_name())
def next_input(self, args):
if 'server_id' not in args:
return ServerIdInputHandler()
# return ret_list
class ServerIdInputHandler(sublime_plugin.TextInputHandler):
def initial_text(self):
return "Buffer name on server"
# def next_input(self, args):
# if "server_id" not in args:
# return ServerIdInputHandler()
# Disconnect Buffer Command
#############################################################################
class CodempDisconnectBufferCommand(sublime_plugin.WindowCommand):
def run(self, remote_name):
buffer = get_buffer_from_remote_name(remote_name)
sublime_asyncio.dispatch(disconnect_buffer_command(buffer))
def input(self, args):
if 'remote_name' not in args:
return RemoteNameInputHandler()
# class ServerIdInputHandler(sublime_plugin.TextInputHandler):
# def initial_text(self):
# return "Buffer name on server"
def input_description(self):
return 'Disconnect Buffer:'
class RemoteNameInputHandler(sublime_plugin.ListInputHandler):
def list_items(self):
global _buffers
ret_list = []
for buff in _buffers:
ret_list.append(buff.remote_name)
return ret_list
# Disconnect Command
#############################################################################
@ -523,6 +352,7 @@ class CodempDisconnectCommand(sublime_plugin.WindowCommand):
def run(self):
sublime_asyncio.sync(disconnect_client())
# Proxy Commands ( NOT USED )
#############################################################################
# class ProxyCodempShareCommand(sublime_plugin.WindowCommand):
@ -563,7 +393,7 @@ class CodempDisconnectCommand(sublime_plugin.WindowCommand):
# return 'Server host:'
## NOT NEEDED ANYMORE
# NOT NEEDED ANYMORE
# def compress_change_region(changes):
# # the bounding region of all text changes.
# txt_a = float("inf")

511
src/codemp_client.py
View file

@ -1,77 +1,508 @@
import asyncio
import Codemp.bindings.codemp_client as libcodemp
from __future__ import annotations
from typing import Optional, Callable
# These are helper wrappers, not very interesting
import sublime
import sublime_plugin
class CodempClient():
import Codemp.ext.sublime_asyncio as sublime_asyncio
def __init__(self):
self.handle = libcodemp.codemp_init()
## Bindings
async def connect(self, server_host): # -> None
import asyncio # noqa: F401
import typing # noqa: F401
import tempfile
import os
from Codemp.bindings.codemp_client import codemp_init, PyCursorEvent, PyTextChange, PyId
# Some utility functions
def status_log(msg):
sublime.status_message("[codemp] {}".format(msg))
print("[codemp] {}".format(msg))
def rowcol_to_region(view, start, end):
a = view.text_point(start[0], start[1])
b = view.text_point(end[0], end[1])
return sublime.Region(a, b)
def is_active(view):
if view.window().active_view() == view:
return True
return False
def safe_listener_detach(txt_listener):
if txt_listener.is_attached():
txt_listener.detach()
###############################################################################
# This class is used as an abstraction between the local buffers (sublime side) and the
# remote buffers (codemp side), to handle the syncronicity.
# This class is mainly manipulated by a VirtualWorkspace, that manages its buffers
# using this abstract class
class VirtualBuffer:
def __init__(
self,
view: sublime.View,
remote_id: str,
workspace: VirtualWorkspace,
buffctl: BufferController,
):
self.view = view
self.codemp_id = remote_id
self.sublime_id = view.buffer_id()
self.worker_task_name = "buffer-worker-{}".format(self.codemp_id)
self.workspace = workspace
self.buffctl = buffctl
self.tmpfile = os.path.join(workspace.rootdir, self.codemp_id)
self.view.set_name(self.codemp_id)
open(self.tmpfile, "a").close()
self.view.retarget(self.tmpfile)
self.view.set_scratch(True)
# mark the view as a codemp view
self.view.set_status("z_codemp_buffer", "[Codemp]")
self.view.settings()["codemp_buffer"] = True
# # start the buffer worker that waits for text_changes in the worker thread
# sublime_asyncio.dispatch(
# self.apply_buffer_change_task(), store_task(self.worker_task_name)
# )
def cleanup(self):
os.remove(self.tmpfile)
# cleanup views
del self.view.settings()["codemp_buffer"]
self.view.erase_status("z_codemp_buffer")
self.view.erase_regions("codemp_cursors")
# the text listener should be detached by the event listener
# on close and on_deactivated events.
# A virtual workspace is a bridge class that aims to translate
# events that happen to the codemp workspaces into sublime actions
class VirtualWorkspace:
def __init__(self, client: VirtualClient, workspace_id: str, handle: Workspace):
self.id = workspace_id
self.sublime_window = sublime.active_window()
self.client = client
self.handle = handle
self.curctl = handle.cursor()
self.active_buffers: list[VirtualBuffer] = []
# REMEMBER TO DELETE THE TEMP STUFF!
# initialise the virtual filesystem
tmpdir = tempfile.mkdtemp(prefix="codemp_")
status_log("setting up virtual fs for workspace in: {} ".format(tmpdir))
self.rootdir = tmpdir
# and add a new "project folder"
proj_data = self.sublime_window.project_data()
if proj_data is None:
proj_data = {"folders": []}
proj_data["folders"].append(
{"name": "CODEMP::" + workspace_id, "path": self.rootdir}
)
self.sublime_window.set_project_data(proj_data)
# start the event listener?
def cleanup(self):
# the worskpace only cares about closing the various open views on its buffers.
# the event listener calls the cleanup code for each buffer independently on its own.
for vbuff in self.active_buffers:
vbuff.view.close()
d = self.sublime_window.project_data()
newf = filter(lambda F: not F["name"].startwith("CODEMP::"), d["folders"])
d["folders"] = newf
self.sublime_window.set_project_data(d)
os.removedirs(self.rootdir)
def get_virtual_by_local(self, id: str) -> Optional[VirtualBuffer]:
return next(
(vbuff for vbuff in self.active_buffers if vbuff.sublime_id == id), None
)
def get_virtual_by_remote(self, id: str) -> Optional[VirtualBuffer]:
return next(
(vbuff for vbuff in self.active_buffers if vbuff.codemp_id == id), None
)
async def attach(self, id: str):
if id is None:
status_log("can't attach if buffer does not exist, aborting.")
return
await self.handle.fetch_buffers()
existing_buffers = self.handle.filetree()
if id not in existing_buffers:
try:
await self.handle.create(id)
except Exception as e:
status_log(f"could not create buffer: {e}")
return
try:
buff_ctl = await self.handle.attach(id)
except Exception as e:
status_log(f"error when attaching to buffer '{id}': {e}")
return
# REMEMBER TO DEAL WITH DELETING THESE THINGS!
view = self.sublime_window.new_file()
vbuff = VirtualBuffer(view, id, self, buff_ctl)
self.active_buffers.append(vbuff)
self.client.spawn_buffer_manager(vbuff)
# if the view is already active calling focus_view() will not trigger the on_activate()
self.sublime_window.focus_view(view)
class VirtualClient:
def __init__(self, on_exit: Callable = None):
self.handle: Client = Client()
self.workspaces: list[VirtualWorkspace] = []
self.active_workspace: VirtualWorkspace = None
self.tm = TaskManager(on_exit)
self.change_clock = 0
def make_active(self, ws: VirtualWorkspace):
# TODO: Logic to deal with swapping to and from workspaces,
# what happens to the cursor tasks etc..
if self.active_workspace is not None:
self.tm.stop_and_pop(f"move-cursor-{self.active_workspace.id}")
self.active_workspace = ws
self.spawn_cursor_manager(ws)
def get_virtual_local(self, id: str) -> Optional[VirtualWorkspace]:
# get's the workspace that contains a buffer
next(
(
vws
for vws in self.workspaces
if vws.get_virtual_by_local(id) is not None
),
None,
)
def get_virtual_remote(self, id: str) -> Optional[VirtualWorkspace]:
# get's the workspace that contains a buffer
next(
(
vws
for vws in self.workspaces
if vws.get_virtual_by_remote(id) is not None
),
None,
)
async def connect(self, server_host: str):
status_log(f"Connecting to {server_host}")
try:
await self.handle.connect(server_host)
except Exception:
sublime.error_message("Could not connect:\n Make sure the server is up.")
return
async def join(self, session): # -> CursorController
return CursorController(await self.handle.join(session))
id = await self.handle.user_id()
print(f"TEST: {id}")
async def create(self, path, content=None): # -> None
await self.handle.create(path, content)
async def join_workspace(
self, workspace_id: str, user="sublime", password="***REMOVED***"
):
try:
status_log(f"Logging into workspace: '{workspace_id}'")
await self.handle.login(user, password, workspace_id)
except Exception as e:
sublime.error_message(f"Failed to login to workspace '{workspace_id}': {e}")
return
async def attach(self, path): # -> BufferController
return BufferController(await self.handle.attach(path))
try:
status_log(f"Joining workspace: '{workspace_id}'")
workspace_handle = await self.handle.join_workspace(workspace_id)
except Exception as e:
sublime.error_message(f"Could not join workspace '{workspace_id}': {e}")
return
async def get_cursor(self): # -> CursorController
return CursorController(await self.handle.get_cursor())
print(workspace_handle.id())
async def get_buffer(self, path): # -> BufferController
return BufferController(await self.handle.get_buffer())
# here we should also start the workspace event watcher task
vws = VirtualWorkspace(self, workspace_id, workspace_handle)
self.make_active(vws)
self.workspaces.append(vws)
async def leave_workspace(self): # -> None
await self.handle.leave_workspace()
def spawn_cursor_manager(self, virtual_workspace: VirtualWorkspace):
async def move_cursor_task(vws):
global _regions_colors
global _palette
async def disconnect_buffer(self, path): # -> None
await self.handle.disconnect_buffer(path)
status_log(f"spinning up cursor worker for workspace '{vws.id}'...")
# TODO: make the matching user/color more solid. now all users have one color cursor.
# Maybe make all cursors the same color and only use annotations as a discriminant.
# idea: use a user id hash map that maps to a color.
try:
while cursor_event := await vws.curctl.recv():
vbuff = vws.get_virtual_by_remote(cursor_event.buffer)
async def select_buffer(self): # -> String
await self.handle.select_buffer()
if vbuff is None:
status_log(
f"Received a cursor event for an unknown or inactive buffer: {cursor_event.buffer}"
)
continue
class CursorController():
def __init__(self, handle):
reg = rowcol_to_region(
vbuff.view, cursor_event.start, cursor_event.end
)
reg_flags = sublime.RegionFlags.DRAW_EMPTY # show cursors.
user_hash = hash(cursor_event.user)
vbuff.view.add_regions(
f"codemp-cursors-{user_hash}",
[reg],
flags=reg_flags,
scope=_regions_colors[user_hash % len(_regions_colors)],
annotations=[cursor_event.user],
annotation_color=_palette[user_hash % len(_palette)],
)
except asyncio.CancelledError:
status_log(f"cursor worker for '{vws.id}' stopped...")
return
self.tm.dispatch(
move_cursor_task(virtual_workspace), f"cursor-ctl-{virtual_workspace.id}"
)
def send_cursor(self, vbuff: VirtualBuffer):
# TODO: only the last placed cursor/selection.
status_log(f"sending cursor position in workspace: {vbuff.workspace.id}")
region = vbuff.view.sel()[0]
start = vbuff.view.rowcol(region.begin()) # only counts UTF8 chars
end = vbuff.view.rowcol(region.end())
vbuff.workspace.curctl.send(vbuff.codemp_id, start, end)
def spawn_buffer_manager(self, vbuff: VirtualBuffer):
status_log("spawning buffer manager")
async def apply_buffer_change_task(vb):
status_log(f"spinning up '{vb.codemp_id}' buffer worker...")
try:
while text_change := await vb.buffctl.recv():
# In case a change arrives to a background buffer, just apply it.
# We are not listening on it. Otherwise, interrupt the listening
# to avoid echoing back the change just received.
if text_change.is_empty():
status_log("change is empty. skipping.")
continue
vb.view.settings()[
"codemp_ignore_next_on_modified_text_event"
] = True
# we need to go through a sublime text command, since the method,
# view.replace needs an edit token, that is obtained only when calling
# a textcommand associated with a view.
vb.view.run_command(
"codemp_replace_text",
{
"start": text_change.start_incl,
"end": text_change.end_excl,
"content": text_change.content,
"change_id": vb.view.change_id(),
},
)
except asyncio.CancelledError:
status_log("'{}' buffer worker stopped...".format(vb.codemp_id))
self.tm.dispatch(
apply_buffer_change_task(vbuff), f"buffer-ctl-{vbuff.codemp_id}"
)
def send_buffer_change(self, changes, vbuff: VirtualBuffer):
# we do not do any index checking, and trust sublime with providing the correct
# sequential indexing, assuming the changes are applied in the order they are received.
for change in changes:
region = sublime.Region(change.a.pt, change.b.pt)
status_log(
"sending txt change: Reg({} {}) -> '{}'".format(
region.begin(), region.end(), change.str
)
)
vbuff.buffctl.send(region.begin(), region.end(), change.str)
class TaskManager:
def __init__(self, exit_handler):
self.tasks = []
self.exit_handler_id = sublime_asyncio.acquire(exit_handler)
def release(self, at_exit):
sublime_asyncio.release(at_exit, self.exit_handler_id)
def dispatch(self, coro, name):
sublime_asyncio.dispatch(coro, self.store_named_lambda(name))
def sync(self, coro):
sublime_asyncio.sync(coro)
def store(self, task):
self.tasks.append(task)
def store_named(self, task, name=None):
task.set_name(name)
self.store(task)
def store_named_lambda(self, name):
def _store(task):
task.set_name(name)
self.store(task)
return _store
def get_task(self, name) -> Optional:
return next((t for t in self.tasks if t.get_name() == name), None)
def get_task_idx(self, name) -> Optional:
return next(
(i for (i, t) in enumerate(self.tasks) if t.get_name() == name), None
)
def pop_task(self, name) -> Optional:
idx = self.get_task_idx(name)
if id is not None:
return self.task.pop(idx)
return None
def stop(self, name):
t = self.get_task(name)
if t is not None:
t.cancel()
def stop_and_pop(self, name) -> Optional:
idx, task = next(
((i, t) for (i, t) in enumerate(self.tasks) if t.get_name() == name),
(None, None),
)
if idx is not None:
task.cancel()
return self.tasks.pop(idx)
def stop_all(self):
for task in self.tasks:
task.cancel()
######################################################################################
# These are helper wrappers, that wrap the coroutines returned from the
# pyo3 bindings into usable awaitable functions.
# These should not be directly extended but rather use the higher level "virtual" counterparts above.
# All methods, without an explicit 'noexcept' are to be treated as failable
# and can throw an error
class CursorController:
def __init__(self, handle) -> None: # noexcept
self.handle = handle
def send(self, buffer_id, start, end): # -> None
self.handle.send(buffer_id, start, end)
def send(self, path: str, start: tuple[int, int], end: tuple[int, int]) -> None:
self.handle.send(path, start, end)
def try_recv(self): # -> Optional[CursorEvent]
def try_recv(self) -> Optional[PyCursorEvent]:
return self.handle.try_recv()
async def recv(self): # -> CursorEvent
async def recv(self) -> PyCursorEvent:
return await self.handle.recv()
async def poll(self): # -> None
async def poll(self) -> None:
# await until new cursor event, then returns
return await self.handle.poll()
class BufferController():
def __init__(self, handle):
class BufferController:
def __init__(self, handle) -> None: # noexcept
self.handle = handle
def content(self): # -> String
return self.content()
def send(self, start, end, txt): # -> None
def send(self, start: int, end: int, txt: str) -> None:
self.handle.send(start, end, txt)
def try_recv(self): # -> Optional[TextChange]
def try_recv(self) -> Optional[PyTextChange]:
return self.handle.try_recv()
async def recv(self): # -> TextChange
async def recv(self) -> PyTextChange:
return await self.handle.recv()
async def poll(self): # -> ??
async def poll(self) -> None:
return await self.handle.poll()
class Workspace:
def __init__(self, handle) -> None: # noexcept
self.handle = handle
async def create(self, path: str) -> None:
await self.handle.create(path)
async def attach(self, path: str) -> BufferController:
return BufferController(await self.handle.attach(path))
async def fetch_buffers(self) -> None:
await self.handle.fetch_buffers()
async def fetch_users(self) -> None:
await self.handle.fetch_users()
async def list_buffer_users(self, path: str) -> list[PyId]:
return await self.handle.list_buffer_users(path)
async def delete(self, path) -> None:
await self.handle.delete(path)
def id(self) -> str: # noexcept
return self.handle.id()
def cursor(self) -> CursorController:
return CursorController(self.handle.cursor())
def buffer_by_name(self, path) -> BufferController:
return BufferController(self.handle.buffer_by_name(path))
def filetree(self) -> list[str]: # noexcept
return self.handle.filetree()
class Client:
def __init__(self) -> None:
self.handle = codemp_init()
async def connect(self, server_host: str) -> None:
await self.handle.connect(server_host)
async def login(self, user: str, password: str, workspace: Optional[str]) -> None:
await self.handle.login(user, password, workspace)
async def join_workspace(self, workspace: str) -> Workspace:
return Workspace(await self.handle.join_workspace(workspace))
async def get_workspace(self, id: str) -> Optional[Workspace]:
return Workspace(await self.handle.get_workspace(id))
async def user_id(self) -> str:
return await self.handle.user_id()