2024-02-10 19:02:11 +01:00
|
|
|
import * as vscode from 'vscode';
|
2024-09-06 12:44:45 +02:00
|
|
|
import * as codemp from '@codemp/codemp';
|
2024-02-14 15:42:40 +01:00
|
|
|
import * as mapping from "./mapping";
|
|
|
|
import { LOGGER } from './extension';
|
2024-02-10 19:02:11 +01:00
|
|
|
|
2024-02-12 19:22:50 +01:00
|
|
|
|
2024-02-14 15:42:40 +01:00
|
|
|
let CACHE = new codemp.OpCache();
|
2024-08-24 20:38:07 +02:00
|
|
|
let client: codemp.Client | null = null;
|
|
|
|
let workspace: codemp.Workspace | null = null;
|
|
|
|
let username: string = "";
|
2024-08-27 22:12:23 +02:00
|
|
|
let mine : boolean;
|
2024-02-10 19:02:11 +01:00
|
|
|
|
2024-08-24 20:38:07 +02:00
|
|
|
export async function connect() {
|
2024-08-29 00:04:58 +02:00
|
|
|
let config = vscode.workspace.getConfiguration('codemp-vscode');
|
|
|
|
let server : string = config.get("server", "http://codemp.dev:50053");
|
|
|
|
let username : string = config.get("username")!;
|
|
|
|
let password : string = config.get("password")!;
|
|
|
|
console.log(server,username,password);
|
|
|
|
client = await codemp.connect(server, username, password);
|
|
|
|
console.log(client);
|
2024-02-10 19:02:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
export async function join() {
|
2024-08-24 20:38:07 +02:00
|
|
|
let workspace_id = await vscode.window.showInputBox({ prompt: "workspace to attach (default to default)" });
|
2024-02-12 19:22:50 +01:00
|
|
|
if (workspace_id === undefined) return // user cancelled with ESC
|
2024-08-24 20:38:07 +02:00
|
|
|
if (workspace_id.length == 0) workspace_id = "diamond"
|
|
|
|
if (client === null) throw "connect first";
|
2024-08-21 18:56:48 +02:00
|
|
|
workspace = await client.join_workspace(workspace_id)
|
2024-02-12 19:22:50 +01:00
|
|
|
let controller = workspace.cursor();
|
2024-08-24 20:38:07 +02:00
|
|
|
controller.callback(async function (controller: codemp.CursorController) {
|
|
|
|
while (true) {
|
|
|
|
let event = await controller.try_recv();
|
|
|
|
if (event === null) break;
|
2024-08-27 22:12:23 +02:00
|
|
|
if (event.user === undefined) {
|
|
|
|
console.log("Skipping cursor without user not found", event)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
let mapp = mapping.colors_cache.get(event.user)
|
|
|
|
if (mapp === undefined) { // first time we see this user
|
|
|
|
mapp = new mapping.UserDecoration(event);
|
|
|
|
mapping.colors_cache.set(event.user, mapp);
|
|
|
|
}
|
|
|
|
let editor = mapping.bufferMapper.by_buffer(event.buffer);
|
|
|
|
if (editor !== undefined) {
|
|
|
|
mapp.apply(editor, event);
|
|
|
|
}
|
2024-08-24 20:38:07 +02:00
|
|
|
}
|
2024-02-10 19:02:11 +01:00
|
|
|
});
|
|
|
|
|
|
|
|
|
2024-08-27 22:12:23 +02:00
|
|
|
vscode.window.onDidChangeTextEditorSelection(async (event: vscode.TextEditorSelectionChangeEvent) => {
|
2024-02-10 19:02:11 +01:00
|
|
|
if (event.kind == vscode.TextEditorSelectionChangeKind.Command) return; // TODO commands might move cursor too
|
2024-02-12 19:22:50 +01:00
|
|
|
let buf = event.textEditor.document.uri;
|
2024-09-06 12:44:45 +02:00
|
|
|
let selection: vscode.Selection = event.selections[0]
|
2024-08-24 20:38:07 +02:00
|
|
|
let anchor: [number, number] = [selection.anchor.line, selection.anchor.character];
|
|
|
|
let position: [number, number] = [selection.active.line, selection.active.character + 1];
|
2024-08-27 22:12:23 +02:00
|
|
|
let buffer = mapping.bufferMapper.by_editor(buf)
|
|
|
|
if (buffer === undefined) return;
|
2024-08-24 20:38:07 +02:00
|
|
|
let cursor: codemp.Cursor = {
|
2024-08-21 18:56:48 +02:00
|
|
|
startRow: selection.anchor.line,
|
|
|
|
startCol: selection.anchor.character,
|
|
|
|
endRow: selection.active.line,
|
2024-08-24 20:38:07 +02:00
|
|
|
endCol: selection.active.character + 1,
|
2024-08-27 22:12:23 +02:00
|
|
|
buffer: buffer,
|
|
|
|
user: undefined,
|
2024-08-21 18:56:48 +02:00
|
|
|
}
|
2024-09-06 12:44:45 +02:00
|
|
|
await controller.send(cursor);
|
2024-02-10 19:02:11 +01:00
|
|
|
});
|
2024-08-29 00:04:58 +02:00
|
|
|
vscode.window.showInformationMessage("Connected to workspace");
|
2024-02-10 19:02:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
export async function createBuffer() {
|
2024-08-24 20:38:07 +02:00
|
|
|
let bufferName: any = (await vscode.window.showInputBox({ prompt: "path of the buffer to create" }))!;
|
|
|
|
if (workspace === null) throw "join a workspace first"
|
2024-02-12 19:22:50 +01:00
|
|
|
workspace.create(bufferName);
|
2024-02-10 19:02:11 +01:00
|
|
|
console.log("new buffer created ", bufferName, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
export async function attach() {
|
2024-08-24 20:38:07 +02:00
|
|
|
let buffer_name: any = (await vscode.window.showInputBox({ prompt: "buffer to attach to" }))!;
|
|
|
|
if (workspace === null) throw "join a workspace first"
|
|
|
|
let buffer: codemp.BufferController = await workspace.attach(buffer_name);
|
2024-02-10 19:02:11 +01:00
|
|
|
console.log("attached to buffer", buffer_name);
|
|
|
|
console.log("buffer", buffer);
|
|
|
|
let editor = vscode.window.activeTextEditor;
|
|
|
|
if (editor === undefined) {
|
|
|
|
let fileUri = buffer_name;
|
|
|
|
let random = (Math.random() + 1).toString(36).substring(2);
|
2024-08-24 20:38:07 +02:00
|
|
|
const fileName = '' + random;
|
2024-02-10 19:02:11 +01:00
|
|
|
const newFileUri = vscode.Uri.file(fileName).with({ scheme: 'untitled', path: "" });
|
|
|
|
await vscode.workspace.openTextDocument(newFileUri);
|
2024-09-06 12:44:45 +02:00
|
|
|
vscode.commands.executeCommand('vscode.open', newFileUri);
|
2024-02-10 19:02:11 +01:00
|
|
|
}
|
|
|
|
editor = vscode.window.activeTextEditor!;
|
|
|
|
vscode.window.showInformationMessage(`Connected to codemp workspace buffer @[${buffer_name}]`);
|
|
|
|
|
2024-08-24 20:38:07 +02:00
|
|
|
let file_uri: vscode.Uri = editor.document.uri;
|
2024-08-27 22:12:23 +02:00
|
|
|
mapping.bufferMapper.register(buffer.get_name(), editor);
|
2024-09-06 12:44:45 +02:00
|
|
|
let bufferContent = await buffer.content();
|
2024-08-27 22:12:23 +02:00
|
|
|
|
|
|
|
|
2024-08-24 20:38:07 +02:00
|
|
|
let range = new vscode.Range(
|
|
|
|
editor.document.positionAt(0),
|
|
|
|
editor.document.positionAt(0)
|
|
|
|
);
|
|
|
|
CACHE.put(buffer_name, 0, bufferContent, 0)
|
|
|
|
editor.edit(editBuilder => {
|
|
|
|
editBuilder
|
|
|
|
.replace(range, bufferContent)
|
|
|
|
});
|
2024-08-27 22:12:23 +02:00
|
|
|
vscode.workspace.onDidChangeTextDocument(async (event: vscode.TextDocumentChangeEvent) => {
|
|
|
|
if(mine) { return }
|
|
|
|
if (event.document.uri !== file_uri) return; // ?
|
2024-02-10 19:02:11 +01:00
|
|
|
for (let change of event.contentChanges) {
|
2024-09-06 12:44:45 +02:00
|
|
|
if (CACHE.get(buffer_name, change.rangeOffset, change.text, change.rangeOffset + change.rangeLength)) continue;
|
2024-02-14 15:42:40 +01:00
|
|
|
LOGGER.info(`onDidChangeTextDocument(event: [${change.rangeOffset}, ${change.text}, ${change.rangeOffset + change.rangeLength}])`);
|
2024-08-27 22:12:23 +02:00
|
|
|
console.log("Sending buffer event");
|
|
|
|
await buffer.send({
|
2024-08-24 20:38:07 +02:00
|
|
|
start: change.rangeOffset,
|
|
|
|
end: change.rangeOffset + change.rangeLength,
|
|
|
|
content: change.text
|
2024-02-10 19:02:11 +01:00
|
|
|
});
|
2024-08-27 22:12:23 +02:00
|
|
|
console.log("Buffer event sent");
|
2024-02-10 19:02:11 +01:00
|
|
|
}
|
|
|
|
});
|
2024-08-27 22:12:23 +02:00
|
|
|
buffer.callback(async (controller: codemp.BufferController) => {
|
2024-08-24 20:38:07 +02:00
|
|
|
while (true) {
|
|
|
|
let event = await controller.try_recv();
|
|
|
|
if (event === null) break;
|
|
|
|
LOGGER.info(`buffer.callback(event: [${event.start}, ${event.content}, ${event.end}])`)
|
|
|
|
console.log(`console log buffer.callback(event: [${event.start}, ${event.content}, ${event.end}])`)
|
|
|
|
CACHE.put(buffer_name, event.start, event.content, event.end);
|
|
|
|
if (editor === undefined) { throw "Open an editor first" }
|
|
|
|
let range = new vscode.Range(
|
|
|
|
editor.document.positionAt(event.start),
|
|
|
|
editor.document.positionAt(event.end)
|
|
|
|
)
|
2024-08-27 22:12:23 +02:00
|
|
|
mine = true
|
|
|
|
await editor.edit(editBuilder => {
|
2024-08-24 20:38:07 +02:00
|
|
|
editBuilder
|
|
|
|
.replace(range, event.content)
|
|
|
|
});
|
2024-08-27 22:12:23 +02:00
|
|
|
mine = false;
|
2024-08-24 20:38:07 +02:00
|
|
|
|
|
|
|
}
|
2024-02-10 19:02:11 +01:00
|
|
|
});
|
2024-08-24 20:38:07 +02:00
|
|
|
|
2024-02-10 19:02:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export async function sync() {
|
2024-08-24 20:38:07 +02:00
|
|
|
if (workspace === null) throw "join a workspace first";
|
2024-02-10 19:02:11 +01:00
|
|
|
let editor = vscode.window.activeTextEditor;
|
2024-02-14 15:42:40 +01:00
|
|
|
if (editor === undefined) throw "no active editor to sync";
|
2024-08-27 22:12:23 +02:00
|
|
|
let buffer_name = mapping.bufferMapper.by_editor(editor.document.uri);
|
|
|
|
if (buffer_name === undefined) throw "No such buffer managed by codemp"
|
|
|
|
let controller = await workspace.buffer_by_name(buffer_name);
|
|
|
|
if (controller === null) throw "No such buffer controller"
|
2024-02-14 15:42:40 +01:00
|
|
|
|
2024-08-27 22:12:23 +02:00
|
|
|
let content = await controller.content();
|
2024-02-14 15:42:40 +01:00
|
|
|
let doc_len = editor.document.getText().length;
|
|
|
|
let range = new vscode.Range(
|
|
|
|
editor.document.positionAt(0),
|
|
|
|
editor.document.positionAt(doc_len)
|
|
|
|
);
|
2024-08-24 20:38:07 +02:00
|
|
|
|
2024-08-27 22:12:23 +02:00
|
|
|
CACHE.put(buffer_name, 0, content, doc_len);
|
2024-02-14 15:42:40 +01:00
|
|
|
editor.edit(editBuilder => editBuilder.replace(range, content));
|
2024-02-10 19:02:11 +01:00
|
|
|
}
|
|
|
|
|
2024-08-24 20:38:07 +02:00
|
|
|
export async function listBuffers() {
|
|
|
|
if (workspace === null) throw "join a workspace first"
|
2024-02-12 19:22:50 +01:00
|
|
|
let buffers = workspace.filetree();
|
|
|
|
console.log(buffers); // improve UX
|
|
|
|
}
|
2024-02-10 19:02:11 +01:00
|
|
|
|
2024-08-29 00:04:58 +02:00
|
|
|
|
|
|
|
export async function createWorkspace(){
|
|
|
|
if(client===null){
|
|
|
|
vscode.window.showInformationMessage("Connect first");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
let workspace_id = await vscode.window.showInputBox({ prompt: "Enter name for workspace" });
|
|
|
|
if(workspace_id===undefined){
|
|
|
|
vscode.window.showInformationMessage("You didn't enter a name");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
await client.create_workspace(workspace_id);
|
2024-08-24 20:38:07 +02:00
|
|
|
}
|
|
|
|
|
2024-08-29 00:04:58 +02:00
|
|
|
export async function listWorkspaces(){
|
|
|
|
if(client===null){
|
|
|
|
vscode.window.showInformationMessage("Connect first");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
let result = await client.list_workspaces(true,true);
|
|
|
|
console.log(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// This method is called when your extension is deactivated
|
|
|
|
export function deactivate() {
|
|
|
|
//Maybe i should disconnect from every workspace and buffer ??? // TODO
|
2024-08-21 18:56:48 +02:00
|
|
|
}
|