fix: code review

Author: Nemikolh

extensions/vscode/src/commands/index.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import { addChapter, addLesson, addPart } from './tutorialkit.add';
-import { deleteUnit } from './tutorialkit.delete';
+import { deleteNode } from './tutorialkit.delete';
 import tutorialkitGoto from './tutorialkit.goto';
 import { initialize } from './tutorialkit.initialize';
 import { loadTutorial } from './tutorialkit.load-tutorial';
@@ -29,7 +29,7 @@ export function useCommands() {
   vscode.commands.registerCommand(CMD.ADD_LESSON, addLesson);
   vscode.commands.registerCommand(CMD.ADD_CHAPTER, addChapter);
   vscode.commands.registerCommand(CMD.ADD_PART, addPart);
-  vscode.commands.registerCommand(CMD.DELETE, deleteUnit);
+  vscode.commands.registerCommand(CMD.DELETE, deleteNode);
   vscode.commands.registerCommand(CMD.REFRESH, tutorialkitRefresh);
 }
 
@@ -39,7 +39,7 @@ export const cmd = {
   selectTutorial: createExecutor<typeof selectTutorial>(CMD.SELECT_TUTORIAL),
   loadTutorial: createExecutor<typeof loadTutorial>(CMD.LOAD_TUTORIAL),
   goto: createExecutor<typeof tutorialkitGoto>(CMD.GOTO),
-  delete: createExecutor<typeof deleteUnit>(CMD.DELETE),
+  delete: createExecutor<typeof deleteNode>(CMD.DELETE),
   addLesson: createExecutor<typeof addLesson>(CMD.ADD_LESSON),
   addPart: createExecutor<typeof addPart>(CMD.ADD_PART),
   addChapter: createExecutor<typeof addChapter>(CMD.ADD_CHAPTER),

extensions/vscode/src/commands/tutorialkit.add.ts

@@ -14,7 +14,7 @@ let capitalize: (string: string) => string;
 })();
 
 export async function addLesson(parent: Node) {
-  const { folderPath, metaFilePath } = await createUnitFolder(parent, 'lesson');
+  const { folderPath, metaFilePath } = await createNodeFolder(parent, 'lesson');
 
   await vscode.workspace.fs.createDirectory(vscode.Uri.joinPath(folderPath, FILES_FOLDER));
   await vscode.workspace.fs.createDirectory(vscode.Uri.joinPath(folderPath, SOLUTION_FOLDER));
@@ -25,22 +25,22 @@ export async function addLesson(parent: Node) {
 }
 
 export async function addChapter(parent: Node) {
-  const { metaFilePath } = await createUnitFolder(parent, 'chapter');
+  const { metaFilePath } = await createNodeFolder(parent, 'chapter');
 
   await cmd.refresh();
 
   return cmd.goto(metaFilePath);
 }
 
 export async function addPart(parent: Node) {
-  const { metaFilePath } = await createUnitFolder(parent, 'part');
+  const { metaFilePath } = await createNodeFolder(parent, 'part');
 
   await cmd.refresh();
 
   return cmd.goto(metaFilePath);
 }
 
-async function getUnitName(unitType: NodeType, unitNumber: number) {
+async function getNodeName(unitType: NodeType, unitNumber: number) {
   const unitName = await vscode.window.showInputBox({
     prompt: `Enter the name of the new ${unitType}`,
     value: `${capitalize(unitType)} ${unitNumber}`,
@@ -54,12 +54,12 @@ async function getUnitName(unitType: NodeType, unitNumber: number) {
   return unitName;
 }
 
-async function createUnitFolder(parent: Node, unitType: NodeType) {
+async function createNodeFolder(parent: Node, nodeType: NodeType) {
   const unitNumber = parent.children.length + 1;
-  const unitName = await getUnitName(unitType, unitNumber);
+  const unitName = await getNodeName(nodeType, unitNumber);
   const unitFolderPath = parent.order ? kebabCase(unitName) : `${unitNumber}-${kebabCase(unitName)}`;
 
-  const metaFile = unitType === 'lesson' ? 'content.mdx' : 'meta.md';
+  const metaFile = nodeType === 'lesson' ? 'content.mdx' : 'meta.md';
   const metaFilePath = vscode.Uri.joinPath(parent.path, unitFolderPath, metaFile);
 
   if (parent.order) {
@@ -69,7 +69,7 @@ async function createUnitFolder(parent: Node, unitType: NodeType) {
 
   await vscode.workspace.fs.writeFile(
     metaFilePath,
-    new TextEncoder().encode(`---\ntype: ${unitType}\ntitle: ${unitName}\n---\n`),
+    new TextEncoder().encode(`---\ntype: ${nodeType}\ntitle: ${unitName}\n---\n`),
   );
 
   return {

extensions/vscode/src/commands/tutorialkit.delete.ts

@@ -2,17 +2,34 @@ import { cmd } from '.';
 import * as vscode from 'vscode';
 import { Node } from '../models/Node';
 import { getLessonsTreeView } from '../global-state';
+import { updateNodeMetadataInVFS } from '../models/tree/update';
 
-export async function deleteUnit(selectedNode: Node | undefined, selectedNodes: Node[] | undefined) {
+export async function deleteNode(selectedNode: Node | undefined, selectedNodes: Node[] | undefined) {
   let nodes: readonly Node[] = (selectedNodes ? selectedNodes : [selectedNode]).filter((node) => node !== undefined);
 
   if (nodes.length === 0) {
     nodes = getLessonsTreeView().selection;
   }
 
+  const parents = new Set<Node>();
+
   for (const node of nodes) {
+    if (node.parent) {
+      parents.add(node.parent);
+      node.parent.removeChild(node);
+    }
+
     await vscode.workspace.fs.delete(node.path, { recursive: true });
   }
 
+  // remove all nodes from parents that that might have been parent of other deleted nodes
+  for (const node of nodes) {
+    parents.delete(node);
+  }
+
+  for (const parent of parents) {
+    await updateNodeMetadataInVFS(parent);
+  }
+
   return cmd.refresh();
 }

extensions/vscode/src/commands/tutorialkit.goto.ts

@@ -16,7 +16,8 @@ export default async (path: string | vscode.Uri | undefined) => {
    * ;
    * ```
    *
-   * Type check correctly despite doing nothing different on each branch.
+   * Type check correctly despite being identical to calling the function
+   * without the branch.
    *
    * To avoid this TypeScript bug here we just cast to any.
    */

extensions/vscode/src/models/Node.ts

@@ -25,6 +25,11 @@ export class Node {
    */
   children: Node[] = [];
 
+  /**
+   * The parent of that node.
+   */
+  parent?: Node;
+
   /**
    * If specified, describe the order of the children.
    * When children are loaded, this should be used to sort
@@ -54,30 +59,73 @@ export class Node {
     private _customName?: string,
   ) {}
 
-  pushChild(folderPath: string) {
+  pushChild(folderName: string) {
     this.childCount += 1;
 
     if (this.order) {
-      this.order.set(folderPath, this.order.size);
+      this.order.set(folderName, this.order.size);
+
+      switch (this.metadata?.type) {
+        case 'chapter': {
+          this.metadata.lessons!.push(folderName);
+          break;
+        }
+        case 'tutorial': {
+          this.metadata.parts!.push(folderName);
+          break;
+        }
+        case 'part': {
+          this.metadata.chapters!.push(folderName);
+          break;
+        }
+      }
+    }
+  }
+
+  removeChild(node: Node) {
+    if (!removeFromArray(this.children, node)) {
+      return;
+    }
 
+    if (this.order) {
       switch (this.metadata?.type) {
         case 'chapter': {
-          this.metadata.lessons!.push(folderPath);
+          removeFromArray(this.metadata.lessons!, node.folderName);
           break;
         }
         case 'tutorial': {
-          this.metadata.parts!.push(folderPath);
+          removeFromArray(this.metadata.parts!, node.folderName);
           break;
         }
         case 'part': {
-          this.metadata.chapters!.push(folderPath);
+          removeFromArray(this.metadata.chapters!, node.folderName);
           break;
         }
       }
     }
   }
+
+  setChildren(children: Node[]) {
+    this.children = children;
+
+    for (const child of this.children) {
+      child.parent = this;
+    }
+  }
 }
 
 export type Metadata = PartSchema | ChapterSchema | LessonSchema | TutorialSchema;
 
 export type NodeType = Metadata['type'];
+
+function removeFromArray<T>(array: T[], element: T) {
+  const index = array.indexOf(element);
+
+  if (index != -1) {
+    array.splice(index, 1);
+
+    return true;
+  }
+
+  return false;
+}

extensions/vscode/src/models/tree/load.ts

@@ -2,7 +2,7 @@ import * as vscode from 'vscode';
 import grayMatter from 'gray-matter';
 import { Metadata, Node } from '../Node';
 import { METADATA_FILES, FILES_FOLDER, SOLUTION_FOLDER } from './constants';
-import { uriDirname } from '../../utils/uri';
+import { Utils } from 'vscode-uri';
 
 export async function loadTutorialTree(tutorialFolderPath: vscode.Uri, tutorialName: string): Promise<Node> {
   const metaFilePath = vscode.Uri.joinPath(tutorialFolderPath, 'meta.md');
@@ -23,7 +23,7 @@ export async function loadChildrenForNode(node: Node) {
     return;
   }
 
-  node.children = await loadTutorialTreeFromBaseFolder(node.path);
+  node.setChildren(await loadTutorialTreeFromBaseFolder(node.path));
 
   // sort children based on their order if defined in the metadata
   const order = node.order;
@@ -83,7 +83,7 @@ async function loadTutorialTreeFromBaseFolder(baseFolderPath: vscode.Uri): Promi
 }
 
 async function updateNodeFromMetadata(node: Node, metadataFilePath: vscode.Uri) {
-  const folderPath = uriDirname(metadataFilePath);
+  const folderPath = Utils.dirname(metadataFilePath);
   const metadataFileContent = await readFileContent(metadataFilePath);
   const parsedContent = grayMatter(metadataFileContent);