jupyter notebook multiline strings are actually strings in the in-memory format

Author: jasongrout

jupyter_notebook/static/phosphor-notebook/src/NotebookComponent.ts

@@ -23,7 +23,7 @@ class MimeBundleComponent extends Component<nbformat.MimeBundle> {
     } else if (x = this.data["image/jpg"]) {
       return img({src:"data:image/jpg;base64,"+x})
     } else if (x = this.data["text/plain"]) {
-      return pre(typeof x === "string" ? x : x.join('\n'));
+      return pre(x);
     }
   }
 }
@@ -45,11 +45,10 @@ export var DisplayData = createFactory(DisplayDataComponent);
 
 class StreamComponent extends Component<nbformat.Stream> {
   render() {
-    return pre(this.data.text.join('\n'));
+    return pre(this.data.text);
   }
 }
 export var Stream = createFactory(StreamComponent);
-//export var x;
 
 class JupyterErrorComponent extends Component<nbformat.JupyterError> {
   render() {
@@ -102,17 +101,15 @@ class CodeCellComponent extends BaseComponent<nbformat.CodeCell> {
     this.node.appendChild(this.editor_node);
     this.node.appendChild(this.output_node);
 
-    var x = this.data.source;
     this._editor  = CodeMirror(this.editor_node, {
       mode: 'python', 
-      value: typeof x === "string" ? x : x.join(""),
+      value: this.data.source,
       lineNumbers: true})
   }
 
   protected onUpdateRequest(msg: IMessage): void {
-    var x = this.data.source;
     // we could call setValue on the editor itself, but the dts file doesn't recognize it.
-    this._editor.getDoc().setValue(typeof x === "string" ? x : x.join(""));
+    this._editor.getDoc().setValue(this.data.source);
     // we may want to save the refs at some point
     render(this.renderOutput(), this.output_node);
   }

jupyter_notebook/static/phosphor-notebook/src/demodata.ts

@@ -1,5 +1,44 @@
 import nbformat = require("./nbformat");
-export var notebook: nbformat.Notebook = {
+
+var multiToString = function(x: string | string[]): string {
+  return (typeof x === "string") ? x : x.join("");
+}
+
+var diskToMemory = function(disknb: any): nbformat.Notebook {
+  // Make a copy
+  var nb = JSON.parse(JSON.stringify(disknb));
+  // Convert multiline strings that are arrays to just strings
+  var cells = nb.cells;
+  for (var i = 0; i<cells.length; i++) {
+    var c = cells[i];
+    var c_type = c.cell_type;
+    if (c_type === "raw" || c_type === "markdown" || c_type === "code") {
+        c.source = multiToString(c.source)
+    }
+    if (c_type === "code") {
+      for (var j = 0; j < c.outputs.length; j++) {
+          var out = c.outputs[j];
+          switch (out.output_type) {
+              case "stream":
+                  out.text = multiToString(out.text);
+                  break;
+              case "execute_result":
+              case "display_data":
+                  var d = out.data;
+                  for (var key in d) {
+                    if (d.hasOwnProperty(key) && key !== "application/json") {
+                      d[key] = multiToString(d[key]);
+                    }
+                  }
+                  break;
+          }
+      }
+    }
+  }
+  return nb;
+}
+
+var notebook_disk = {
  "cells": [
   {
    "cell_type": "markdown",
@@ -9,9 +48,9 @@ export var notebook: nbformat.Notebook = {
     "\n",
     "This is a *test* of the **markdown** system.\n",
     "* Let's use [marked.js](https://github.com/chjj/marked)\n",
-    "* Does this work?\n",
+    "* Does this work? <b>hi</b>\n",
     "\n",
-    "Math formulas like $e^{\\pi i} + 1 = 0$ and the following work too. \\\\[\\int x^2\\, dx\\\\]\n"
+    "Math formulas like $e^{\\pi i} + 1 = 0$ and the following work too. $$\\int x^2\\, dx$$\n"
    ]
   },
   {
@@ -153,3 +192,5 @@ export var notebook: nbformat.Notebook = {
  "nbformat": 4,
  "nbformat_minor": 0
 }
+
+export var notebook: nbformat.Notebook = diskToMemory(notebook_disk);

jupyter_notebook/static/phosphor-notebook/src/nbformat.ts

@@ -1,44 +1,44 @@
 // Notebook format interfaces
 
+// In the notebook format *disk* representation, this would be string | string[]
+export type multilineString = string;
+
 export
 interface MimeBundle {
-    // values are always string|string[] if we pretend that the application/json key doesn't exist
-    [key: string]: string | string[];
+    // values are always multilineString if we pretend that the application/json key doesn't exist
+    // in fact, the in-memory representation always is a string
+    [key: string]: multilineString;
 
     // we fudge the standard a bit here by not telling Typescript about the application/json
-    // key, which will be a Javascript object if it exists.  If we want to tell 
+    // key, which will be a Javascript object if it exists.  If we want to tell, then uncomment below:
     //"application/json": {};
-
-    // we special-case some keys because we what we assume about them
-    "image/png": string;
-    "image/jpg": string;
 }
 
 export
 interface ExecuteResult {
-    output_type: string; /*"execute_result"*/
+    output_type: string; // "execute_result"
     execution_count: number;
     data:  MimeBundle;
     metadata: {};
 }
 
 export
 interface DisplayData {
-    output_type: string; /*"display_data"*/
+    output_type: string; // "display_data"
     data: MimeBundle;
     metadata: {};
 }
 
 export
 interface Stream {
-    output_type: string; /*"stream"*/
+    output_type: string; // "stream"
     name: string;
-    text: string[];
+    text: multilineString;
 }
 
 export
 interface JupyterError {
-    output_type: string; /*"error"*/
+    output_type: string; // "error"
     ename: string;
     evalue: string;
     traceback: string[];
@@ -62,7 +62,7 @@ interface BaseCell {
 export
 interface RawCell extends BaseCell {
     cell_type: string; /*"raw"*/
-    source: string | string[];
+    source: multilineString;
     metadata: {
         format?: string;
     }
@@ -71,13 +71,13 @@ interface RawCell extends BaseCell {
 export
 interface MarkdownCell extends BaseCell {
     cell_type: string; /*"markdown"*/
-    source: string | string[];
+    source: multilineString;
 }
 
 export
 interface CodeCell extends BaseCell {
     cell_type: string; /*"code"*/
-    source: string | string[];
+    source: multilineString;
     metadata: {
         collapsed?: boolean;
         scrolled?: boolean | string;