hexedtech/codemp-vscode
3
0
Fork 0
mirror of https://github.com/hexedtech/codemp-vscode.git synced 2024-11-22 07:24:49 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

feat: removed rust from extension and added to glue

Browse source
This commit is contained in:
frelodev 2024-08-21 18:55:46 +02:00
parent a45f5fbaa0
commit 26f2c3b836
8 changed files with 0 additions and 507 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
Cargo.toml
View file

@ -1,29 +0,0 @@
[package]
name = "codemp-vscode"
version = "0.0.1"
description = "VSCode extension for CodeMP"
edition = "2021"
[lib]
crate-type = ["cdylib"]
path = "src/rust/lib.rs"
[dependencies]
codemp = { git = "ssh://git@github.com/codewithotherpeopleandchangenamelater/codemp.git", tag="v0.6.0", features = ["client", "woot"] }
tracing = "0.1"
tracing-subscriber = "0.3.17"
uuid = { version = "1.3.1", features = ["v4"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
rmpv = "1"
async-trait = "0.1.68"
napi = { version = "2", features = ["full"] }
napi-derive = "2"
futures = "0.3.28"
tokio = {version = "1.32.0", features = ["full"] }
[build-dependencies]
napi-build = "2"
[profile.release]
lto = true

5
build.rs
View file

@ -1,5 +0,0 @@
extern crate napi_build;
fn main() {
napi_build::setup();
}

110
src/rust/buffer.rs
View file

@ -1,110 +0,0 @@
use std::sync::Arc;
use napi::threadsafe_function::{ErrorStrategy::Fatal, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode};
use napi_derive::napi;
use codemp::api::Controller;
use crate::JsCodempError;
/// BUFFER
#[napi(object)]
pub struct JsTextChange {
pub span: JsRange,
pub content: String,
}
#[napi(object)]
pub struct JsRange{
pub start: i32,
pub end: i32,
}
impl From::<codemp::api::TextChange> for JsTextChange {
fn from(value: codemp::api::TextChange) -> Self {
JsTextChange {
// TODO how is x.. represented ? span.end can never be None
span: JsRange { start: value.span.start as i32, end: value.span.end as i32 },
content: value.content,
}
}
}
impl From::<Arc<codemp::buffer::Controller>> for JsBufferController {
fn from(value: Arc<codemp::buffer::Controller>) -> Self {
JsBufferController(value)
}
}
#[napi]
pub struct JsBufferController(Arc<codemp::buffer::Controller>);
/*#[napi]
pub fn delta(string : String, start: i64, txt: String, end: i64 ) -> Option<JsCodempOperationSeq> {
Some(JsCodempOperationSeq(string.diff(start as usize, &txt, end as usize)?))
}*/
#[napi]
impl JsBufferController {
#[napi(ts_args_type = "fun: (event: JsTextChange) => void")]
pub fn callback(&self, fun: napi::JsFunction) -> napi::Result<()>{
let tsfn : ThreadsafeFunction<codemp::api::TextChange, Fatal> =
fun.create_threadsafe_function(0,
|ctx : ThreadSafeCallContext<codemp::api::TextChange>| {
Ok(vec![JsTextChange::from(ctx.value)])
}
)?;
let _controller = self.0.clone();
tokio::spawn(async move {
//tokio::time::sleep(std::time::Duration::from_secs(1)).await;
loop {
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
match _controller.recv().await {
Ok(event) => {
tsfn.call(event, ThreadsafeFunctionCallMode::NonBlocking); //check this shit with tracing also we could use Ok(event) to get the error
},
Err(codemp::Error::Deadlocked) => continue,
Err(e) => break tracing::warn!("error receiving: {}", e),
}
}
});
Ok(())
}
#[napi]
pub fn content(&self) -> String {
self.0.content()
}
#[napi]
pub fn get_name(&self) -> String {
self.0.name().to_string()
}
#[napi]
pub async fn recv(&self) -> napi::Result<JsTextChange> {
Ok(
self.0.recv().await
.map_err(|e| napi::Error::from(JsCodempError(e)))?
.into()
)
}
#[napi]
pub fn send(&self, op: JsTextChange) -> napi::Result<()> {
// TODO might be nice to take ownership of the opseq
let new_text_change = codemp::api::TextChange {
span: op.span.start as usize .. op.span.end as usize,
content: op.content,
};
Ok(self.0.send(new_text_change).map_err(JsCodempError)?)
}
}

45
src/rust/client.rs
View file

@ -1,45 +0,0 @@
use napi_derive::napi;
use crate::JsCodempError;
use crate::workspace::JsWorkspace;
#[napi]
/// main codemp client session
pub struct JsCodempClient(tokio::sync::RwLock<codemp::Client>);
#[napi]
/// connect to codemp servers and return a client session
pub async fn connect(addr: Option<String>) -> napi::Result<JsCodempClient>{
let client = codemp::Client::new(addr.as_deref().unwrap_or("http://codemp.alemi.dev:50053"))
.await
.map_err(JsCodempError)?;
Ok(JsCodempClient(tokio::sync::RwLock::new(client)))
}
#[napi]
impl JsCodempClient {
#[napi]
/// login against AuthService with provided credentials, optionally requesting access to a workspace
pub async fn login(&self, username: String, password: String, workspace_id: Option<String>) -> napi::Result<()> {
self.0.read().await.login(username, password, workspace_id).await.map_err(JsCodempError)?;
Ok(())
}
#[napi]
/// join workspace with given id (will start its cursor controller)
pub async fn join_workspace(&self, workspace: String) -> napi::Result<JsWorkspace> {
Ok(JsWorkspace::from(self.0.write().await.join_workspace(&workspace).await.map_err(JsCodempError)?))
}
#[napi]
/// get workspace with given id, if it exists
pub async fn get_workspace(&self, workspace: String) -> Option<JsWorkspace> {
self.0.read().await.get_workspace(&workspace).map(|w| JsWorkspace::from(w))
}
#[napi]
/// return current sessions's user id
pub async fn user_id(&self) -> String {
self.0.read().await.user_id().to_string()
}
}

90
src/rust/cursor.rs
View file

@ -1,90 +0,0 @@
use std::sync::Arc;
use napi_derive::napi;
use uuid::Uuid;
use napi::threadsafe_function::{ThreadsafeFunction, ThreadSafeCallContext, ThreadsafeFunctionCallMode, ErrorStrategy};
use codemp::api::Controller;
use crate::JsCodempError;
#[napi]
pub struct JsCursorController(Arc<codemp::cursor::Controller>);
impl From::<Arc<codemp::cursor::Controller>> for JsCursorController {
fn from(value: Arc<codemp::cursor::Controller>) -> Self {
JsCursorController(value)
}
}
#[napi]
impl JsCursorController {
#[napi(ts_args_type = "fun: (event: JsCursorEvent) => void")]
pub fn callback(&self, fun: napi::JsFunction) -> napi::Result<()>{
let tsfn : ThreadsafeFunction<codemp::proto::cursor::CursorEvent, ErrorStrategy::Fatal> =
fun.create_threadsafe_function(0,
|ctx : ThreadSafeCallContext<codemp::proto::cursor::CursorEvent>| {
Ok(vec![JsCursorEvent::from(ctx.value)])
}
)?;
let _controller = self.0.clone();
tokio::spawn(async move {
loop {
match _controller.recv().await {
Ok(event) => {
tsfn.call(event.clone(), ThreadsafeFunctionCallMode::NonBlocking); //check this shit with tracing also we could use Ok(event) to get the error
},
Err(codemp::Error::Deadlocked) => continue,
Err(e) => break tracing::warn!("error receiving: {}", e),
}
}
});
Ok(())
}
#[napi]
pub fn send(&self, buffer: String, start: (i32, i32), end: (i32, i32)) -> napi::Result<()> {
let pos = codemp::proto::cursor::CursorPosition {
buffer: buffer.into(),
start: codemp::proto::cursor::RowCol::from(start),
end: codemp::proto::cursor::RowCol::from(end),
};
Ok(self.0.send(pos).map_err(JsCodempError)?)
}
}
#[derive(Debug)]
#[napi(object)]
pub struct JsCursorEvent {
pub user: String,
pub buffer: String,
pub start: JsRowCol,
pub end: JsRowCol,
}
impl From::<codemp::proto::cursor::CursorEvent> for JsCursorEvent {
fn from(value: codemp::proto::cursor::CursorEvent) -> Self {
let pos = value.position;
let start = pos.start;
let end = pos.end;
JsCursorEvent {
user: Uuid::from(value.user).to_string(),
buffer: pos.buffer.into(),
start: JsRowCol { row: start.row, col: start.col },
end: JsRowCol { row: end.row, col: end.col },
}
}
}
#[derive(Debug)]
#[napi(object)]
pub struct JsRowCol {
pub row: i32,
pub col: i32
}
impl From::<codemp::proto::cursor::RowCol> for JsRowCol {
fn from(value: codemp::proto::cursor::RowCol) -> Self {
JsRowCol { row: value.row, col: value.col }
}
}

68
src/rust/lib.rs
View file

@ -1,68 +0,0 @@
#![deny(clippy::all)]
pub mod client;
pub mod workspace;
pub mod cursor;
pub mod buffer;
pub mod op_cache;
#[derive(Debug)]
struct JsCodempError(codemp::Error);
impl From::<JsCodempError> for napi::Error {
fn from(value: JsCodempError) -> Self {
napi::Error::new(napi::Status::GenericFailure, &format!("CodempError: {:?}", value))
}
}
use napi_derive::napi;
#[napi]
pub struct JsLogger(std::sync::Arc<tokio::sync::Mutex<tokio::sync::mpsc::Receiver<String>>>);
#[napi]
impl JsLogger {
#[napi(constructor)]
pub fn new(debug: Option<bool>) -> JsLogger {
let (tx, rx) = tokio::sync::mpsc::channel(256);
let level = if debug.unwrap_or(false) { tracing::Level::DEBUG } else {tracing::Level::INFO }; //TODO: study this tracing subscriber and customize it
let format = tracing_subscriber::fmt::format()
.with_level(true)
.with_target(true)
.with_thread_ids(false)
.with_thread_names(false)
.with_ansi(false)
.with_file(false)
.with_line_number(false)
.with_source_location(false)
.compact();
tracing_subscriber::fmt()
.event_format(format)
.with_max_level(level)
.with_writer(std::sync::Mutex::new(JsLoggerProducer(tx)))
.init();
JsLogger(std::sync::Arc::new(tokio::sync::Mutex::new(rx)))
}
#[napi]
pub async fn message(&self) -> Option<String> {
self.0
.lock()
.await
.recv()
.await
}
}
#[derive(Debug, Clone)]
struct JsLoggerProducer(tokio::sync::mpsc::Sender<String>);
impl std::io::Write for JsLoggerProducer {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
// TODO this is a LOSSY logger!!
let _ = self.0.try_send(String::from_utf8_lossy(buf).to_string()); // ignore: logger disconnected or with full buffer
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> { Ok(()) }
}

104
src/rust/op_cache.rs
View file

@ -1,104 +0,0 @@
use std::collections::HashMap;
use napi_derive::napi;
pub type OpTuple = (String, u32, String, u32); // buf_path, start, text, end
#[napi]
pub struct OpCache {
store: HashMap<OpTuple, i32>
}
#[napi]
impl OpCache {
#[napi(constructor)]
pub fn new() -> Self {
OpCache {
store: HashMap::new()
}
}
#[napi]
pub fn to_string(&self) -> String {
self.store.iter()
.map(|(k, v)| format!("{}x Op(@{} {}:{} '{}')", k.0, v, k.1, k.3, k.2))
.collect::<Vec<String>>()
.join(", ")
}
#[napi]
pub fn put(&mut self, buf: String, start: u32, text: String, end: u32) -> i32 {
let op = (buf, start, text, end);
match self.store.get_mut(&op) {
Some(val) => {
if *val < 0 { *val = 0 }
*val += 1;
*val
},
None => {
self.store.insert(op, 1);
return 1;
}
}
}
#[napi]
pub fn get(&mut self, buf: String, start: u32, text: String, end: u32) -> bool {
let op = (buf, start, text, end);
match self.store.get_mut(&op) {
Some(val) => {
*val -= 1;
*val >= 0
}
None => {
tracing::warn!("never seen this op: {:?}", op);
self.store.insert(op, -1);
false
},
}
}
}
//a
//consume a
//a
#[cfg(test)]
mod test {
#[test]
fn opcache_put_increments_internal_counter() {
let mut op = super::OpCache::new();
assert_eq!(op.put("default".into(), 0, "hello world".into(), 0), 1); // 1: did not already contain it
assert_eq!(op.put("default".into(), 0, "hello world".into(), 0), 2); // 2: already contained it
}
#[test]
fn op_cache_get_checks_count() {
let mut op = super::OpCache::new();
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), false);
assert_eq!(op.put("default".into(), 0, "hello world".into(), 0), 1);
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), true);
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), false);
}
#[test]
fn op_cache_get_works_for_multiple_puts() {
let mut op = super::OpCache::new();
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), false);
assert_eq!(op.put("default".into(), 0, "hello world".into(), 0), 1);
assert_eq!(op.put("default".into(), 0, "hello world".into(), 0), 2);
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), true);
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), true);
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), false);
}
#[test]
fn op_cache_different_keys(){
let mut op = super::OpCache::new();
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), false);
assert_eq!(op.put("default".into(), 0, "hello world".into(), 0), 1);
assert_eq!(op.get("workspace".into(), 0, "hi".into(), 0), false);
assert_eq!(op.put("workspace".into(), 0, "hi".into(), 0), 1);
assert_eq!(op.get("workspace".into(), 0, "hi".into(), 0), true);
assert_eq!(op.get("default".into(), 0, "hello world".into(), 0), true);
}
}

56
src/rust/workspace.rs
View file

@ -1,56 +0,0 @@
use std::sync::Arc;
use napi_derive::napi;
use crate::{JsCodempError, buffer::JsBufferController, cursor::JsCursorController};
#[napi]
/// a reference to a codemp workspace
pub struct JsWorkspace(Arc<codemp::Workspace>);
impl From<Arc<codemp::Workspace>> for JsWorkspace {
fn from(value: Arc<codemp::Workspace>) -> Self {
JsWorkspace(value)
}
}
#[napi]
impl JsWorkspace {
#[napi]
pub fn id(&self) -> String {
self.0.id()
}
#[napi]
pub fn filetree(&self) -> Vec<String> {
self.0.filetree()
}
#[napi]
pub fn cursor(&self) -> JsCursorController {
JsCursorController::from(self.0.cursor())
}
#[napi]
pub fn buffer_by_name(&self, path: String) -> Option<JsBufferController> {
self.0.buffer_by_name(&path).map(|b| JsBufferController::from(b))
}
#[napi]
pub async fn create(&self, path: String) -> napi::Result<()> {
Ok(self.0.create(&path).await.map_err(JsCodempError)?)
}
#[napi]
pub async fn attach(&self, path: String) -> napi::Result<JsBufferController> {
Ok(JsBufferController::from(self.0.attach(&path).await.map_err(JsCodempError)?))
}
/*#[napi]
pub async fn delete(&self, path: String) -> napi::Result<>{
self.0.delete(&path)
}*/
}