Promise logic is infectious like a disease

IPython/html/static/services/kernels/comm.js

@@ -1,202 +1,211
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
 ], function(IPython, $, utils) {
     "use strict";
 
     //-----------------------------------------------------------------------
     // CommManager class
     //-----------------------------------------------------------------------
     
     var CommManager = function (kernel) {
         this.comms = {};
         this.targets = {};
         if (kernel !== undefined) {
             this.init_kernel(kernel);
         }
     };
     
     CommManager.prototype.init_kernel = function (kernel) {
         // connect the kernel, and register message handlers
         this.kernel = kernel;
         var msg_types = ['comm_open', 'comm_msg', 'comm_close'];
         for (var i = 0; i < msg_types.length; i++) {
             var msg_type = msg_types[i];
             kernel.register_iopub_handler(msg_type, $.proxy(this[msg_type], this));
         }
     };
     
     CommManager.prototype.new_comm = function (target_name, data, callbacks, metadata) {
         // Create a new Comm, register it, and open its Kernel-side counterpart
         // Mimics the auto-registration in `Comm.__init__` in the IPython Comm
         var comm = new Comm(target_name);
         this.register_comm(comm);
         comm.open(data, callbacks, metadata);
         return comm;
     };
     
     CommManager.prototype.register_target = function (target_name, f) {
         // Register a target function for a given target name
         this.targets[target_name] = f;
     };
     
     CommManager.prototype.unregister_target = function (target_name, f) {
         // Unregister a target function for a given target name
         delete this.targets[target_name];
     };
     
     CommManager.prototype.register_comm = function (comm) {
         // Register a comm in the mapping
-        this.comms[comm.comm_id] = comm;
+        this.comms[comm.comm_id] = new Promise(function(resolve) {resolve(comm);});
         comm.kernel = this.kernel;
         return comm.comm_id;
     };
     
     CommManager.prototype.unregister_comm = function (comm) {
         // Remove a comm from the mapping
         delete this.comms[comm.comm_id];
     };
     
     // comm message handlers
     
     CommManager.prototype.comm_open = function (msg) {
         var content = msg.content;
         var that = this;
-        
-        return utils.load_class(content.target_name, content.target_module, 
+        var comm_id = content.comm_id;
+
+        this.comms[comm_id] = utils.load_class(content.target_name, content.target_module, 
             this.targets).then(function(target) {
 
-            var comm = new Comm(content.target_name, content.comm_id);
-            that.register_comm(comm);
+            var comm = new Comm(content.target_name, comm_id);
+            comm.kernel = that.kernel;
             try {
                 target(comm, msg);
             } catch (e) {
                 comm.close();
                 that.unregister_comm(comm);
                 var wrapped_error = new utils.WrappedError("Exception opening new comm", e);
                 console.error(wrapped_error);
                 return Promise.reject(wrapped_error);
             }
             return comm;
         }, utils.reject('Could not open comm', true));
+        return this.comms[comm_id];
     };
     
-    CommManager.prototype.comm_close = function (msg) {
+    CommManager.prototype.comm_close = function(msg) {
         var content = msg.content;
-        var comm = this.comms[content.comm_id];
-        if (comm === undefined) {
+        if (!this.comms[content.comm_id]) {
+            console.error('Comm promise not found for comm id ' + content.comm_id);
             return;
         }
-        this.unregister_comm(comm);
-        try {
-            comm.handle_close(msg);
-        } catch (e) {
-            console.log("Exception closing comm: ", e, e.stack, msg);
-        }
+
+        this.comms[content.comm_id].then(function(comm) {
+            this.unregister_comm(comm);
+            try {
+                comm.handle_close(msg);
+            } catch (e) {
+                console.log("Exception closing comm: ", e, e.stack, msg);
+            }
+        });
     };
     
-    CommManager.prototype.comm_msg = function (msg) {
+    CommManager.prototype.comm_msg = function(msg) {
         var content = msg.content;
-        var comm = this.comms[content.comm_id];
-        if (comm === undefined) {
+        if (!this.comms[content.comm_id]) {
+            console.error('Comm promise not found for comm id ' + content.comm_id);
             return;
         }
-        try {
-            comm.handle_msg(msg);
-        } catch (e) {
-            console.log("Exception handling comm msg: ", e, e.stack, msg);
-        }
+
+        this.comms[content.comm_id].then(function(comm) {
+            try {
+                comm.handle_msg(msg);
+            } catch (e) {
+                console.log("Exception handling comm msg: ", e, e.stack, msg);
+            }
+        });
     };
     
     //-----------------------------------------------------------------------
     // Comm base class
     //-----------------------------------------------------------------------
     
     var Comm = function (target_name, comm_id) {
         this.target_name = target_name;
         this.comm_id = comm_id || utils.uuid();
         this._msg_callback = this._close_callback = null;
 
         var that = this;
         this.msg_promise = new Promise(function(resolve, reject) {
             that.resolve_msg_promise = resolve;
         });
     };
     
     // methods for sending messages
     Comm.prototype.open = function (data, callbacks, metadata) {
         var content = {
             comm_id : this.comm_id,
             target_name : this.target_name,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_open", content, callbacks, metadata);
     };
     
     Comm.prototype.send = function (data, callbacks, metadata, buffers) {
         var content = {
             comm_id : this.comm_id,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_msg", content, callbacks, metadata, buffers);
     };
     
     Comm.prototype.close = function (data, callbacks, metadata) {
         var content = {
             comm_id : this.comm_id,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_close", content, callbacks, metadata);
     };
     
     // methods for registering callbacks for incoming messages
     Comm.prototype._register_callback = function (key, callback) {
         this['_' + key + '_callback'] = callback;
     };
     
     Comm.prototype.on_msg = function (callback) {
         this._register_callback('msg', callback);
         this.resolve_msg_promise();
     };
     
     Comm.prototype.on_close = function (callback) {
         this._register_callback('close', callback);
     };
     
     // methods for handling incoming messages
     
     Comm.prototype._maybe_callback = function (key, msg) {
         var callback = this['_' + key + '_callback'];
         if (callback) {
             try {
                 callback(msg);
             } catch (e) {
                 console.log("Exception in Comm callback", e, e.stack, msg);
             }
         }
     };
     
     Comm.prototype.handle_msg = function (msg) {
         var that = this;
-        this.msg_promise.then(function() {
+        this.msg_promise = this.msg_promise.then(function() {
             that._maybe_callback('msg', msg);
+            return Promise.resolve();
         });
     };
     
     Comm.prototype.handle_close = function (msg) {
         this._maybe_callback('close', msg);
     };
     
     // For backwards compatability.
     IPython.CommManager = CommManager;
     IPython.Comm = Comm;
 
     return {
         'CommManager': CommManager,
         'Comm': Comm
     };
 });

IPython/html/tests/widgets/widget_float.js

@@ -1,109 +1,107
 // Test widget float class
 casper.notebook_test(function () {
     var float_text = {};
     float_text.query = '.widget-area .widget-subarea .my-second-float-text input';
     float_text.index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'float_widget = widgets.FloatText()\n' +
         'display(float_widget)\n' + 
         'float_widget._dom_classes = ["my-second-float-text"]\n' + 
         'print(float_widget.model_id)\n');
     this.execute_cell_then(float_text.index, function(index){
         float_text.model_id = this.get_output_cell(index).text.trim();
     });
 
     // Wait for the widget to actually display.
     this.wait_for_element(float_text.index, float_text.query);
 
     // Continue with the tests
     this.then(function(){        
         this.test.assert(this.cell_element_exists(float_text.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(float_text.index, float_text.query),
             'Widget float textbox exists.');
 
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
-        console.log('send keys');
         this.sendKeys(float_text.query, '1.05');
-        console.log('send keys done');
     });
 
     this.wait_for_widget(float_text);
 
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1.05\n', 
             'Float textbox value set.');
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
         this.sendKeys(float_text.query, '123456789.0');
     });
 
     this.wait_for_widget(float_text);
     
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '123456789.0\n', 
             'Long float textbox value set (probably triggers throttling).');
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
         this.sendKeys(float_text.query, '12hello');
     });
 
     this.wait_for_widget(float_text);
 
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '12.0\n', 
             'Invald float textbox value caught and filtered.');
     });
 
     var float_text_query = '.widget-area .widget-subarea .widget-numeric-text';
     var slider = {};
     slider.query = '.widget-area .widget-subarea .slider';
     slider.index = this.append_cell(
         'floatrange = [widgets.BoundedFloatText(), \n' +
         '    widgets.FloatSlider()]\n' +
         '[display(floatrange[i]) for i in range(2)]\n' + 
         'print("Success")\n');
     this.execute_cell_then(slider.index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create float range cell executed with correct output.');
     });
 
     // Wait for the widgets to actually display.
     this.wait_for_element(slider.index, slider.query);
     this.wait_for_element(slider.index, float_text_query);
 
     this.then(function(){
         this.test.assert(this.cell_element_exists(slider.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(slider.index, slider.query),
             'Widget slider exists.');
 
         this.test.assert(this.cell_element_exists(slider.index, float_text_query),
             'Widget float textbox exists.');
     });
 
     index = this.append_cell(
         'for widget in floatrange:\n' +
         '    widget.max = 50.0\n' +
         '    widget.min = -50.0\n' +
         '    widget.value = 25.0\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Float range properties cell executed with correct output.');
 
         this.test.assert(this.cell_element_exists(slider.index, slider.query), 
             'Widget slider exists.');
 
         this.test.assert(this.cell_element_function(slider.index, slider.query, 
             'slider', ['value']) == 25.0,
             'Slider set to Python value.');
     });
 });
  No newline at end of file