Move js donc into function themselves.

Then it is possible in the browser js console to get the documentation
interactively.

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

@@ -284,6 +284,7 define([
         });
     };
 
+    Kernel.prototype.restart = function (success, error) {
     /**
      * POST /api/kernels/[:kernel_id]/restart
      *
@@ -293,7 +294,6 define([
      * @param {function} [success] - function executed on ajax success
      * @param {function} [error] - functon executed on ajax error
      */
-    Kernel.prototype.restart = function (success, error) {
         this.events.trigger('kernel_restarting.Kernel', {kernel: this});
         this.stop_channels();
 
@@ -325,6 +325,7 define([
         });
     };
 
+    Kernel.prototype.reconnect = function () {
     /**
      * Reconnect to a disconnected kernel. This is not actually a
      * standard HTTP request, but useful function nonetheless for
@@ -332,7 +333,6 define([
      *
      * @function reconnect
      */
-    Kernel.prototype.reconnect = function () {
         if (this.is_connected()) {
             return;
         }
@@ -344,6 +344,7 define([
         this.start_channels();
     };
 
+    Kernel.prototype._on_success = function (success) {
     /**
      * Handle a successful AJAX request by updating the kernel id and
      * name from the response, and then optionally calling a provided
@@ -352,7 +353,6 define([
      * @function _on_success
      * @param {function} success - callback
      */
-    Kernel.prototype._on_success = function (success) {
         var that = this;
         return function (data, status, xhr) {
             if (data) {
@@ -366,6 +366,7 define([
         };
     };
 
+    Kernel.prototype._on_error = function (error) {
     /**
      * Handle a failed AJAX request by logging the error message, and
      * then optionally calling a provided callback.
@@ -373,7 +374,6 define([
      * @function _on_error
      * @param {function} error - callback
      */
-    Kernel.prototype._on_error = function (error) {
         return function (xhr, status, err) {
             utils.log_ajax_error(xhr, status, err);
             if (error) {
@@ -382,6 +382,7 define([
         };
     };
 
+    Kernel.prototype._kernel_created = function (data) {
     /**
      * Perform necessary tasks once the kernel has been started,
      * including actually connecting to the kernel.
@@ -389,12 +390,12 define([
      * @function _kernel_created
      * @param {Object} data - information about the kernel including id
      */
-    Kernel.prototype._kernel_created = function (data) {
         this.id = data.id;
         this.kernel_url = utils.url_join_encode(this.kernel_service_url, this.id);
         this.start_channels();
     };
 
+    Kernel.prototype._kernel_connected = function () {
     /**
      * Perform necessary tasks once the connection to the kernel has
      * been established. This includes requesting information about
@@ -402,7 +403,6 define([
      *
      * @function _kernel_connected
      */
-    Kernel.prototype._kernel_connected = function () {
         this.events.trigger('kernel_connected.Kernel', {kernel: this});
         this.events.trigger('kernel_starting.Kernel', {kernel: this});
         // get kernel info so we know what state the kernel is in
@@ -413,6 +413,7 define([
         });
     };
 
+    Kernel.prototype._kernel_dead = function () {
     /**
      * Perform necessary tasks after the kernel has died. This closing
      * communication channels to the kernel if they are still somehow
@@ -420,17 +421,16 define([
      *
      * @function _kernel_dead
      */
-    Kernel.prototype._kernel_dead = function () {
         this.stop_channels();
     };
 
+    Kernel.prototype.start_channels = function () {
     /**
      * Start the `shell`and `iopub` channels.
      * Will stop and restart them if they already exist.
      *
      * @function start_channels
      */
-    Kernel.prototype.start_channels = function () {
         var that = this;
         this.stop_channels();
         var ws_host_url = this.ws_url + this.kernel_url;
@@ -504,19 +504,20 define([
         this.channels.stdin.onmessage = $.proxy(this._handle_input_request, this);
     };
 
+    Kernel.prototype._ws_opened = function (evt) {
     /**
      * Handle a websocket entering the open state,
      * signaling that the kernel is connected when all channels are open.
      *
      * @function _ws_opened
      */
-    Kernel.prototype._ws_opened = function (evt) {
         if (this.is_connected()) {
             // all events ready, trigger started event.
             this._kernel_connected();
         }
     };
 
+    Kernel.prototype._ws_closed = function(ws_url, error) {
     /**
      * Handle a websocket entering the closed state. This closes the
      * other communication channels if they are open. If the websocket
@@ -526,7 +527,6 define([
      * @param {string} ws_url - the websocket url
      * @param {bool} error - whether the connection was closed due to an error
      */
-    Kernel.prototype._ws_closed = function(ws_url, error) {
         this.stop_channels();
 
         this.events.trigger('kernel_disconnected.Kernel', {kernel: this});
@@ -553,13 +553,13 define([
         }
     };
     
+    Kernel.prototype.stop_channels = function () {
     /**
      * Close the websocket channels. After successful close, the value
      * in `this.channels[channel_name]` will be null.
      *
      * @function stop_channels
      */
-    Kernel.prototype.stop_channels = function () {
         var that = this;
         var close = function (c) {
             return function () {
@@ -580,6 +580,7 define([
         }
     };
 
+    Kernel.prototype.is_connected = function () {
     /**
      * Check whether there is a connection to the kernel. This
      * function only returns true if all channel objects have been
@@ -588,7 +589,6 define([
      * @function is_connected
      * @returns {bool} - whether there is a connection
      */
-    Kernel.prototype.is_connected = function () {
         for (var c in this.channels) {
             // if any channel is not ready, then we're not connected
             if (this.channels[c] === null) {
@@ -601,6 +601,7 define([
         return true;
     };
 
+    Kernel.prototype.is_fully_disconnected = function () {
     /**
      * Check whether the connection to the kernel has been completely
      * severed. This function only returns true if all channel objects
@@ -609,7 +610,6 define([
      * @function is_fully_disconnected
      * @returns {bool} - whether the kernel is fully disconnected
      */
-    Kernel.prototype.is_fully_disconnected = function () {
         for (var c in this.channels) {
             if (this.channels[c] === null) {
                 return true;
@@ -618,12 +618,12 define([
         return false;
     };
     
+    Kernel.prototype.send_shell_message = function (msg_type, content, callbacks, metadata, buffers) {
     /**
      * Send a message on the Kernel's shell channel
      *
      * @function send_shell_message
      */
-    Kernel.prototype.send_shell_message = function (msg_type, content, callbacks, metadata, buffers) {
         if (!this.is_connected()) {
             throw new Error("kernel is not connected");
         }
@@ -633,6 +633,7 define([
         return msg.header.msg_id;
     };
 
+    Kernel.prototype.kernel_info = function (callback) {
     /**
      * Get kernel info
      *
@@ -643,7 +644,6 define([
      * The callback will be passed the complete `kernel_info_reply` message documented
      * [here](http://ipython.org/ipython-doc/dev/development/messaging.html#kernel-info)
      */
-    Kernel.prototype.kernel_info = function (callback) {
         var callbacks;
         if (callback) {
             callbacks = { shell : { reply : callback } };
@@ -651,6 +651,7 define([
         return this.send_shell_message("kernel_info_request", {}, callbacks);
     };
 
+    Kernel.prototype.inspect = function (code, cursor_pos, callback) {
     /**
      * Get info on an object
      *
@@ -663,7 +664,6 define([
      * @param cursor_pos {integer}
      * @param callback {function}
      */
-    Kernel.prototype.inspect = function (code, cursor_pos, callback) {
         var callbacks;
         if (callback) {
             callbacks = { shell : { reply : callback } };
@@ -677,6 +677,7 define([
         return this.send_shell_message("inspect_request", content, callbacks);
     };
 
+    Kernel.prototype.execute = function (code, callbacks, options) {
     /**
      * Execute given code into kernel, and pass result to callback.
      *
@@ -726,7 +727,6 define([
      * arugment.  Payload handlers will be passed the corresponding
      * payload and the execute_reply message.
      */
-    Kernel.prototype.execute = function (code, callbacks, options) {
         var content = {
             code : code,
             silent : true,