Fixes multiple bugs (#131)

hbcarlos · web-flow · commit bd6388031d86 · 2023-01-19T11:18:18.000+01:00
* Fixes multiple bugs

* Fix tests

* Review

* Improves tests

* Lint
diff --git a/javascript/package.json b/javascript/package.json
@@ -58,7 +58,8 @@
         "prettier": "^2.6.0",
         "rimraf": "^3.0.0",
         "typedoc": "^0.23.21",
-        "typescript": "^4.8.0"
+        "typescript": "^4.8.0",
+        "process": "0.11.10"
     },
     "publishConfig": {
         "access": "public"
diff --git a/javascript/src/api.ts b/javascript/src/api.ts
@@ -388,9 +388,9 @@ export namespace ISharedNotebook {
     disableDocumentWideUndoRedo?: boolean;
 
     /**
-     * The language preference for the model.
+     * The content of the notebook.
      */
-    languagePreference?: string;
+    data?: Partial<nbformat.INotebookContent>;
   }
 }
 
diff --git a/javascript/src/ycell.ts b/javascript/src/ycell.ts
@@ -18,8 +18,8 @@ import type {
   ISharedRawCell,
   SharedCell
 } from './api.js';
-import { IYText } from './ytext';
-import { YNotebook } from './ynotebook';
+import { IYText } from './ytext.js';
+import { YNotebook } from './ynotebook.js';
 
 /**
  * Cell type.
@@ -606,12 +606,21 @@ export class YBaseCell<Metadata extends nbformat.IBaseCellMetadata>
             });
             break;
           case 'update':
-            if (!JSONExt.deepEqual(change.oldValue, this._ymetadata.get(key))) {
+            const newValue = this._ymetadata.get(key);
+            const oldValue = change.oldValue;
+            let equal = true;
+            if (typeof oldValue == 'object' && typeof newValue == 'object') {
+              equal = JSONExt.deepEqual(oldValue, newValue);
+            } else {
+              equal = oldValue === newValue;
+            }
+
+            if (!equal) {
               this._metadataChanged.emit({
                 key,
-                newValue: this._ymetadata.get(key),
-                oldValue: change.oldValue,
-                type: 'change'
+                type: 'change',
+                oldValue,
+                newValue
               });
             }
             break;
diff --git a/javascript/src/yfile.ts b/javascript/src/yfile.ts
@@ -5,8 +5,8 @@
 
 import * as Y from 'yjs';
 import type { Delta, FileChange, ISharedFile, ISharedText } from './api.js';
-import { IYText } from './ytext';
-import { YDocument } from './ydocument';
+import { IYText } from './ytext.js';
+import { YDocument } from './ydocument.js';
 
 /**
  * Shareable text file.
diff --git a/javascript/src/ynotebook.ts b/javascript/src/ynotebook.ts
@@ -16,13 +16,13 @@ import type {
   SharedCell
 } from './api.js';
 
-import { YDocument } from './ydocument';
+import { YDocument } from './ydocument.js';
 import {
   createCell,
   createCellModelFromSharedType,
   YBaseCell,
   YCellType
-} from './ycell';
+} from './ycell.js';
 
 /**
  * Shared implementation of the Shared Document types.
@@ -46,7 +46,7 @@ export class YNotebook
    *
    * @param options
    */
-  constructor(options: ISharedNotebook.IOptions = {}) {
+  constructor(options: Omit<ISharedNotebook.IOptions, 'data'> = {}) {
     super();
     this._disableDocumentWideUndoRedo =
       options.disableDocumentWideUndoRedo ?? false;
@@ -75,14 +75,15 @@ export class YNotebook
     const ynotebook = new YNotebook({
       disableDocumentWideUndoRedo: options.disableDocumentWideUndoRedo ?? false
     });
-    const ymetadata = new Y.Map();
-    ymetadata.set('language_info', { name: options.languagePreference ?? '' });
-    ymetadata.set('kernelspec', {
-      name: '',
-      display_name: ''
-    });
-    ynotebook.ymeta.set('metadata', ymetadata);
 
+    const data: nbformat.INotebookContent = {
+      cells: options.data?.cells ?? [],
+      nbformat: options.data?.nbformat ?? 4,
+      nbformat_minor: options.data?.nbformat_minor ?? 5,
+      metadata: options.data?.metadata ?? {}
+    };
+
+    ynotebook.fromJSON(data);
     return ynotebook;
   }
 
@@ -483,12 +484,21 @@ export class YNotebook
             });
             break;
           case 'update':
-            if (!JSONExt.deepEqual(change.oldValue, ymetadata.get(key))) {
+            const newValue = ymetadata.get(key);
+            const oldValue = change.oldValue;
+            let equal = true;
+            if (typeof oldValue == 'object' && typeof newValue == 'object') {
+              equal = JSONExt.deepEqual(oldValue, newValue);
+            } else {
+              equal = oldValue === newValue;
+            }
+
+            if (!equal) {
               this._metadataChanged.emit({
                 key,
                 type: 'change',
-                oldValue: change.oldValue,
-                newValue: ymetadata.get(key)
+                oldValue,
+                newValue
               });
             }
             break;
diff --git a/javascript/test/ycell.spec.ts b/javascript/test/ycell.spec.ts
@@ -0,0 +1,230 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { IMapChange, YCodeCell, YNotebook } from '../src';
+
+describe('@jupyter/ydoc', () => {
+  describe('YCell standalone', () => {
+    test('should set source', () => {
+      const codeCell = YCodeCell.create();
+      codeCell.setSource('test');
+      expect(codeCell.getSource()).toBe('test');
+      codeCell.dispose();
+    });
+
+    test('should update source', () => {
+      const codeCell = YCodeCell.create();
+      codeCell.setSource('test');
+      codeCell.updateSource(0, 0, 'hello');
+      expect(codeCell.getSource()).toBe('hellotest');
+      codeCell.dispose();
+    });
+
+    test('should get metadata', () => {
+      const cell = YCodeCell.create();
+      const metadata = {
+        collapsed: true,
+        editable: false,
+        name: 'cell-name'
+      };
+
+      cell.setMetadata(metadata);
+
+      expect(cell.metadata).toEqual({
+        ...metadata,
+        jupyter: { outputs_hidden: true }
+      });
+      cell.dispose();
+    });
+
+    test('should get all metadata', () => {
+      const cell = YCodeCell.create();
+      const metadata = {
+        jupyter: { outputs_hidden: true },
+        editable: false,
+        name: 'cell-name'
+      };
+
+      cell.setMetadata(metadata);
+
+      expect(cell.getMetadata()).toEqual({ ...metadata, collapsed: true });
+      cell.dispose();
+    });
+
+    test('should get one metadata', () => {
+      const cell = YCodeCell.create();
+      const metadata = {
+        collapsed: true,
+        editable: false,
+        name: 'cell-name'
+      };
+
+      cell.setMetadata(metadata);
+
+      expect(cell.getMetadata('editable')).toEqual(metadata.editable);
+      cell.dispose();
+    });
+
+    it.each([null, undefined, 1, true, 'string', { a: 1 }, [1, 2]])(
+      'should get single metadata %s',
+      value => {
+        const cell = YCodeCell.create();
+        const metadata = {
+          collapsed: true,
+          editable: false,
+          name: 'cell-name',
+          test: value
+        };
+
+        cell.setMetadata(metadata);
+
+        expect(cell.getMetadata('test')).toEqual(value);
+        cell.dispose();
+      }
+    );
+
+    test('should set one metadata', () => {
+      const cell = YCodeCell.create();
+      const metadata = {
+        collapsed: true,
+        editable: false,
+        name: 'cell-name'
+      };
+
+      cell.setMetadata(metadata);
+      cell.setMetadata('test', 'banana');
+
+      expect(cell.getMetadata('test')).toEqual('banana');
+      cell.dispose();
+    });
+
+    test('should emit all metadata changes', () => {
+      const notebook = YNotebook.create();
+
+      const metadata = {
+        collapsed: true,
+        editable: false,
+        name: 'cell-name'
+      };
+
+      const changes: IMapChange[] = [];
+      notebook.metadataChanged.connect((_, c) => {
+        changes.push(c);
+      });
+      notebook.metadata = metadata;
+
+      expect(changes).toHaveLength(3);
+      expect(changes).toEqual([
+        {
+          type: 'add',
+          key: 'collapsed',
+          newValue: metadata.collapsed,
+          oldValue: undefined
+        },
+        {
+          type: 'add',
+          key: 'editable',
+          newValue: metadata.editable,
+          oldValue: undefined
+        },
+        {
+          type: 'add',
+          key: 'name',
+          newValue: metadata.name,
+          oldValue: undefined
+        }
+      ]);
+
+      notebook.dispose();
+    });
+
+    test('should emit a add metadata change', () => {
+      const cell = YCodeCell.create();
+      const metadata = {
+        collapsed: true,
+        editable: false,
+        name: 'cell-name'
+      };
+      cell.metadata = metadata;
+
+      const changes: IMapChange[] = [];
+      cell.metadataChanged.connect((_, c) => {
+        changes.push(c);
+      });
+      cell.setMetadata('test', 'banana');
+
+      try {
+        expect(changes).toHaveLength(1);
+        expect(changes).toEqual([
+          { type: 'add', key: 'test', newValue: 'banana', oldValue: undefined }
+        ]);
+      } finally {
+        cell.dispose();
+      }
+    });
+
+    test('should emit a delete metadata change', () => {
+      const cell = YCodeCell.create();
+      const metadata = {
+        collapsed: true,
+        editable: false,
+        name: 'cell-name'
+      };
+      cell.metadata = metadata;
+
+      const changes: IMapChange[] = [];
+      cell.setMetadata('test', 'banana');
+
+      cell.metadataChanged.connect((_, c) => {
+        changes.push(c);
+      });
+      cell.deleteMetadata('test');
+
+      try {
+        expect(changes).toHaveLength(1);
+        expect(changes).toEqual([
+          {
+            type: 'remove',
+            key: 'test',
+            newValue: undefined,
+            oldValue: 'banana'
+          }
+        ]);
+      } finally {
+        cell.dispose();
+      }
+    });
+
+    test('should emit an update metadata change', () => {
+      const cell = YCodeCell.create();
+      const metadata = {
+        collapsed: true,
+        editable: false,
+        name: 'cell-name'
+      };
+      cell.metadata = metadata;
+
+      const changes: IMapChange[] = [];
+      cell.setMetadata('test', 'banana');
+
+      cell.metadataChanged.connect((_, c) => {
+        changes.push(c);
+      });
+      cell.setMetadata('test', 'orange');
+
+      try {
+        expect(changes).toHaveLength(1);
+        expect(changes).toEqual([
+          {
+            type: 'change',
+            key: 'test',
+            newValue: 'orange',
+            oldValue: 'banana'
+          }
+        ]);
+      } finally {
+        cell.dispose();
+      }
+    });
+  });
+});
diff --git a/javascript/test/yfile.spec.ts b/javascript/test/yfile.spec.ts
diff --git a/javascript/test/ynotebook.spec.ts b/javascript/test/ynotebook.spec.ts
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -388,9 +388,9 @@ export namespace ISharedNotebook {`
`388`	`388`	`disableDocumentWideUndoRedo?: boolean;`
`389`	`389`
`390`	`390`	`/**`
`391`		`- * The language preference for the model.`
	`391`	`+ * The content of the notebook.`
`392`	`392`	`*/`
`393`		`- languagePreference?: string;`
	`393`	`+ data?: Partial<nbformat.INotebookContent>;`
`394`	`394`	`}`
`395`	`395`	`}`
`396`	`396`