Some changes

godcodehunter · godcodehunter · commit 3aab211c68b7 · 2021-07-27T05:42:06.000+07:00
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
@@ -506,3 +506,43 @@ pub struct CompletionResolveData {
     pub full_import_path: String,
     pub imported_name: String,
 }
+// Request for derive selected data and do subscribes to their changes
+pub enum SubscriptionRequest {}
+
+impl Request for SubscriptionRequest {
+    type Params = SubscriptionRequestParams;
+    type Result = String;
+    const METHOD: &'static str = "rust-analyzer/subscription";
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct SubscriptionRequestParams {
+    pub data_objects: Vec<String>
+}
+
+#[derive(Debug)]
+pub enum DataUpdate{}
+
+impl Notification for DataUpdate {
+    type Params = DataUpdateParams;
+    const METHOD: &'static str = "data/update";
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct DataUpdateParams {
+    pub patch: Patch,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct Patch {
+    pub delete: Vec<usize>,   
+    pub append: Vec<Append>,
+}   
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Append {
+    pub target_id: usize,
+    //TODO: ...
+} 
diff --git a/editors/code/src/test_explorer.ts b/editors/code/src/test_explorer.ts
@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
-import { func } from 'vscode-languageclient/lib/utils/is';
+import { array, func } from 'vscode-languageclient/lib/utils/is';
 import { strict } from 'assert';
 import { Func } from 'mocha';
 
@@ -11,20 +11,36 @@ function getIconUri(iconName: string, theme: string): vscode.Uri {
 	return vscode.Uri.file(path.join(iconsRootPath, theme, `${iconName}.svg`));
 }
 
+/// Runnable.
+
+type Node = Workspace | Crate | Module | Function;
+
+enum NodeKind {
+    Workspace,
+    Crate,
+    Module,
+    Function,
+}
+
+type Session = Iterable<Workspace>;
+
 interface Workspace {
+    kind: NodeKind.Workspace,
     id: string, 
     crates: Crate[],
     location: string,
 }
 
 interface Crate {
+    kind: NodeKind.Crate,
     id: string, 
     name: string,
     modules: Module[], 
     location: string,
 }
 
 interface Module {
+    kind: NodeKind.Module,
     id: string, 
     name: string,
     modules?: Module[], 
@@ -38,16 +54,50 @@ enum TestKind {
 }
 
 interface Function {
+    kind: NodeKind.Function,
     id: string, 
     name: string,
     location: string,
-    kind: TestKind,
+    testKind: TestKind,
+}
+
+/// The view synchronized with RA data by `DeltaUpdate`'s. The update is an array   
+/// of elementary actions called a `Patch`. After applying an update to the tree 
+/// it will become synchronized.
+
+type DeltaUpdate = Iterable<Patch>;
+
+type Patch = Delete | Update | Create;
+
+enum PatchKind {
+    Delete = "DELETE",
+    Update = "UPDATE",
+    Create = "CREATE"
+}
+
+interface Delete {
+    kind: PatchKind.Delete,
+    targetId: string,
+} 
+
+interface Update {
+    kind: PatchKind.Update,
+    targetId: string,
+    payload: {
+        name?: string,
+        location?: string,
+        testKind?: TestKind,
+    },
+}
+
+interface Create {
+    kind: PatchKind.Create,
+    targetId: string,
+    payload: Node,
 }
 
 class Workspace extends vscode.TreeItem {  
-    get description(): string {
-        return this.location;
-    }
+    description = this.location;
 
     iconPath = {
         light: getIconUri('squares', 'dark'),
@@ -69,11 +119,10 @@ class Crate extends vscode.TreeItem {
         super(name, vscode.TreeItemCollapsibleState.Collapsed);
         this.location = location;
         this.id = id;
+        this.modules = modules;
     }
     
-    get description(): string {
-        return this.location;
-    }
+    description = this.location;
 
     iconPath = {
         light: getIconUri('squares', 'dark'),
@@ -98,9 +147,7 @@ class Module extends vscode.TreeItem {
         this.id = id;
     }   
 
-    get description(): string {
-        return this.location;
-    }
+    description = this.location;
 
     iconPath = {
         light: getIconUri('squares', 'dark'),
@@ -148,18 +195,14 @@ class Function extends vscode.TreeItem {
         }
     }
        
-    get description(): string {
-        return this.location;
-    }
+    description = this.location;
 
     getChildren(): null {
         return null;
     }   
 }
 
-type Node = Workspace | Crate | Module | Function;
-
-function bfs(root: Node, process: (node: Node) => void) {
+function bfs(root: Node, process: (parentField: Node[], node: Node) => void) {
     let queue: Array<Node> = [root];
     while(queue.length != 0) {
         let current = queue.pop();
@@ -189,59 +232,109 @@ export class RunnableDataProvider implements vscode.TreeDataProvider<Node> {
 
 export class RunnableView {
     private dataProvider: RunnableDataProvider;
-    private data: Node;
+    private tree: Node;
 
     constructor(context: vscode.ExtensionContext) {
         this.dataProvider = new RunnableDataProvider()
     }
-
-    public applyUpdate(deltaUpdate: Patch[]) {
-        deltaUpdate.map((patch) => {
-            switch(patch.kind) {
-                case PatchKind.Create: 
-                    find(patch.targetId);
-                break;
-                case PatchKind.Delete:
-                    find();
-                break;
-                case PatchKind.Update:
-                    find();
-                break;
+  
+    handleCreate(node: Node, patch: Create) {
+        switch(node.kind) {
+            case NodeKind.Workspace: {
+                if (patch.payload.kind != NodeKind.Crate) {
+                    throw Error(`${patch.payload.kind} cant't be payload for ${NodeKind.Workspace} target`);
+                }
+                node.crates.push(patch.payload);
+            }
+            break;
+            case NodeKind.Crate: {
+                if (patch.payload.kind != NodeKind.Module) {
+                    throw Error(`${patch.payload.kind} cant't be payload for ${NodeKind.Crate} target`);
+                }
+                node.modules.push(patch.payload);
             }
-        });    
+            break;
+            case NodeKind.Module: {
+                if (patch.payload.kind == NodeKind.Module) {
+                    if(node.modules == undefined) {
+                        node.modules = [];
+                    }
+                    node.modules!.push(patch.payload);
+                } else if (patch.payload.kind == NodeKind.Function) {
+                    if(node.modules == undefined) {
+                        node.modules = [];
+                    }
+                    node.targets!.push(patch.payload);
+                } else {
+                    throw Error(`${patch.payload.kind} cant't be payload for ${NodeKind.Module} target`);
+                }
+            }
+            break;
+            case NodeKind.Function: {
+                throw Error("Function can't be a target for Create's patch");
+            }
+        }
     }
-}
-
-/// The view synchronized with RA data by delta updates. The update is an array   
-/// of elementary actions called a `Patch`. After applying an update to the tree 
-/// it will become synchronized.
-
-type Patch = Delete | Update | Create;
 
-enum PatchKind {
-    Delete = "DELETE",
-    Update = "UPDATE",
-    Create = "CREATE"
-}
+    handleDelete(node: Node, parentField: Array<Node>) {
+        const index = parentField.indexOf(node);
+        parentField.splice(index, 1);
+    }
 
-interface Delete {
-    kind: PatchKind.Delete,
-    id: string,
-} 
+    handleUpdate(node: Node, patch: Update) {
+        switch(node.kind) {
+            case NodeKind.Workspace: {
+                node.location = patch.payload.location!;
+            }
+            break;
+            case NodeKind.Crate: {
+                node.location = patch.payload.location!; 
+                node.name = patch.payload.name!;
+            }
+            break;
+            case NodeKind.Module: {
+                node.name = patch.payload.name!;
+                node.location = patch.payload.location!;
+            }
+            break;
+            case NodeKind.Function: {
+                node.name = patch.payload.name!;
+                node.location = patch.payload.location!;
+                node.testKind = patch.payload.testKind!;
+            }
+            break;
+        }
+    }
 
-interface Update {
-    kind: PatchKind.Update,
-    payload: {
-        name?: string,
-        location?: string,
-        kind?: TestKind,
-    },
+    public applyUpdate(update: DeltaUpdate) {
+        for (let patch of update) {
+            bfs(this.tree, (parentField, node) => {
+                if(node.id == patch.targetId) {
+                    switch(patch.kind) {
+                        case PatchKind.Create: {
+                            this.handleCreate(node, patch);
+                        }
+                        break;
+                        case PatchKind.Delete: {
+                            this.handleDelete(node, parentField)
+                        }
+                        break;
+                        case PatchKind.Update: {
+                            this.handleUpdate(node, patch)
+                        }
+                        break;
+                    }
+                }
+            })
+        }  
+    }
 }
 
-interface Create {
-    kind: PatchKind.Create,
-    targetId: string,
-    payload: Node,
+export class TestView {
+    
+    constructor() {
+        let controller = vscode.tests.createTestController();
+    }
 }
 
 // function runExecutable() {
