Clean code, retab and minor fix

remove unused code, convert some tab to space, and correct some
semicolon according to jslint

jlint fixes

IPython/frontend/html/notebook/static/js/completer.js

@@ -1,232 +1,231 b''
 // function completer.
 //
 // completer should be a class that take an cell instance
 
 var IPython = (function(IPython ) {
     // that will prevent us from misspelling
     "use strict";
 
     // easyier key mapping
     var key = IPython.utils.keycodes;
 
     // what is the common start of all completions
     function sharedStart(B){
-            if(B.length == 1){return B[0]}
-            var A = new Array()
+            if(B.length == 1){return B[0];}
+            var A = new Array();
             for(var i=0; i< B.length; i++)
             {
                A.push(B[i].str);
             }
             if(A.length > 1 ){
-                var tem1, tem2, s, A = A.slice(0).sort();
+                var tem1, tem2, s;
+                A = A.slice(0).sort();
                 tem1 = A[0];
                 s = tem1.length;
                 tem2 = A.pop();
                 while(s && tem2.indexOf(tem1) == -1){
                     tem1 = tem1.substring(0, --s);
                 }
                 if (tem1 == ""  || tem2.indexOf(tem1) != 0){return null;}
                 return { str  : tem1,
                          type : "computed",
                          from : B[0].from,
                          to   : B[0].to
                 };
             }
             return null;
         }
 
 
     var Completer = function(cell) {
         this.editor = cell.code_mirror;
         // if last caractere before cursor is not in this, we stop completing
         this.reg = /[0-9a-z.]/i; // casse insensitive
-    }
+    };
 
     Completer.prototype.kernelCompletionRequest = function(){
         var cur  = this.editor.getCursor();
         var line = this.editor.getLine(cur.line);
         // one could fork here and directly call finish completing if kernel is busy
         var callbacks = {'complete_reply': $.proxy(this.finish_completing,this)};
         IPython.notebook.kernel.complete(line, cur.ch, callbacks);
-    }
+    };
 
 
     Completer.prototype.startCompletion = function()
     {
         // call for a 'first' completion, that will set the editor and do some
         // special behaviour like autopicking if only one completion availlable
         //
         if (this.editor.somethingSelected()) return;
         this.done = false;
         // use to get focus back on opera
         this.carryOnCompletion(true);
-    }
+    };
 
     Completer.prototype.carryOnCompletion = function(ff) {
         // Pass true as parameter if you want the commpleter to autopick when
         // only one completion. This function is automatically reinvoked at
         // each keystroke with ff = false
 
         var cur = this.editor.getCursor();
         var pre_cursor = this.editor.getRange({line:cur.line,ch:cur.ch-1},cur);
 
         // we need to check that we are still on a word boundary
         // because while typing the completer is still reinvoking itself
         if(!this.reg.test(pre_cursor)){ this.close(); return;}
 
         this.autopick = false;
         if( ff != 'undefined' && ff==true)
         { this.autopick=true; }
 
         // We want a single cursor position.
         if (this.editor.somethingSelected()) return;
 
         //one kernel completion came back, finish_completing will be called with the results
         this.kernelCompletionRequest();
-    }
+    };
 
     Completer.prototype.finish_completing =function (content) {
         // let's build a function that wrap all that stuff into what is needed
         // for the new completer:
         var matched_text = content.matched_text;
         var matches = content.matches;
 
         var cur = this.editor.getCursor();
         var results = CodeMirror.contextHint(this.editor);
 
         // append the introspection result, in order, at at the beginning of
         // the table and compute the replacement range from current cursor
         // positon and matched_text length.
         for(var i= matches.length-1; i>=0 ;--i)
         {
             results.unshift(
                 {   str  : matches[i],
                     type : "introspection",
                     from : {line: cur.line, ch: cur.ch-matched_text.length},
                     to   : {line: cur.line, ch: cur.ch}
-                })
+                });
         }
 
         // one the 2 sources results have been merge, deal with it
         this.raw_result = results;
 
         // if empty result return
         if (!this.raw_result || !this.raw_result.length) return;
 
         // When there is only one completion, use it directly.
         if (this.autopick == true && this.raw_result.length == 1)
             {
                 this.insert(this.raw_result[0]);
-                return true;
+            return;
             }
 
         if (this.raw_result.length == 1)
         {
             // test if first and only completion totally matches
             // what is typed, in this case dismiss
-            var str = this.raw_result[0].str
-            var cur = this.editor.getCursor();
+            var str = this.raw_result[0].str;
             var pre_cursor = this.editor.getRange({line:cur.line,ch:cur.ch-str.length},cur);
             if(pre_cursor == str)
                 { this.close(); return ; }
         }
 
         this.complete = $('<div/>').addClass('completions');
         this.complete.attr('id','complete');
 
         this.sel = $('<select/>')
                 .attr('multiple','true')
                 .attr('size',Math.min(10,this.raw_result.length));
         var pos = this.editor.cursorCoords();
 
         // TODO: I propose to remove enough horizontal pixel
         // to align the text later
         this.complete.css('left',pos.x+'px');
         this.complete.css('top',pos.yBot+'px');
         this.complete.append(this.sel);
 
         $('body').append(this.complete);
         //build the container
         var that = this;
-        this.sel.dblclick(function(){that.pick()});
+        this.sel.dblclick(function(){that.pick();});
         this.sel.blur(this.close);
-        this.sel.keydown(function(event){that.keydown(event)});
+        this.sel.keydown(function(event){that.keydown(event);});
 
         this.build_gui_list(this.raw_result);
 
         this.sel.focus();
         // Opera sometimes ignores focusing a freshly created node
         if (window.opera) setTimeout(function(){if (!this.done) this.sel.focus();}, 100);
         return true;
     }
 
     Completer.prototype.insert = function(completion) {
         this.editor.replaceRange(completion.str, completion.from, completion.to);
         }
 
     Completer.prototype.build_gui_list = function(completions){
         // Need to clear the all list
         for (var i = 0; i < completions.length; ++i) {
             var opt = $('<option/>')
                 .text(completions[i].str)
                 .addClass(completions[i].type);
             this.sel.append(opt);
         }
         this.sel.children().first().attr('selected','true');
     }
 
     Completer.prototype.close = function() {
             if (this.done) return;
             this.done = true;
             $('.completions').remove();
         }
 
     Completer.prototype.pick = function(){
         this.insert(this.raw_result[this.sel[0].selectedIndex]);
         this.close();
         var that = this;
         setTimeout(function(){that.editor.focus();}, 50);
         }
 
 
     Completer.prototype.keydown = function(event) {
       var code = event.keyCode;
+      var that = this;
       // Enter
       if (code == key.enter) {CodeMirror.e_stop(event); this.pick();}
       // Escape or backspace
       else if (code == key.esc ) {CodeMirror.e_stop(event); this.close(); this.editor.focus();}
       else if (code == key.space || code == key.backspace) {this.close(); this.editor.focus();}
       else if (code == key.tab){
             //all the fastforwarding operation,
             //Check that shared start is not null which can append with prefixed completion
             // like %pylab , pylab have no shred start, and ff will result in py<tab><tab>
             // to erase py
             var sh = sharedStart(this.raw_result);
             if(sh){
                 this.insert(sh);
             }
             this.close();
             CodeMirror.e_stop(event);
             this.editor.focus();
             //reinvoke self
-            var that = this;
             setTimeout(function(){that.carryOnCompletion();}, 50);
       }
       else if (code == key.upArrow || code == key.downArrow) {
         // need to do that to be able to move the arrow
         // when on the first or last line ofo a code cell
         event.stopPropagation();
       }
       else if (code != key.upArrow && code != key.downArrow) {
         this.close(); this.editor.focus();
         //we give focus to the editor immediately and call sell in 50 ms
-        var that = this;
         setTimeout(function(){that.carryOnCompletion();}, 50);
       }
     }
 
 
     IPython.Completer = Completer;
 
     return IPython;
 }(IPython));

IPython/frontend/html/notebook/static/js/tooltip.js

@@ -1,297 +1,294 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2008-2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Tooltip
 //============================================================================
 //
-// you can set the autocall time by setting `IPython.notebook.time_before_tooltip` in ms
+// you can set the autocall time by setting `IPython.tooltip.time_before_tooltip` in ms
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     // tooltip constructor
     var Tooltip = function () {
         var that = this;
         this.time_before_tooltip = 1200;
 
         // handle to html
         this.tooltip = $('#tooltip');
         var tooltip = this.tooltip;
         this._hidden = true;
 
         // variable for consecutive call
         this._old_cell = null ;
         this._old_request = null ;
         this._consecutive_conter = 0;
 
         // 'sticky ?'
         this._sticky = false;
 
         // contain the button in the upper right corner
         this.buttons = $('<div/>')
               .addClass('tooltipbuttons');
 
         // will contain the docstring
         this.text    = $('<div/>')
           .addClass('tooltiptext')
           .addClass('smalltooltip');
 
         // build the buttons menu on the upper right
 
         // expand the tooltip to see more
         var expandlink=$('<a/>').attr('href',"#")
               .addClass("ui-corner-all") //rounded corner
               .attr('role',"button")
               .attr('id','expanbutton')
               .click(function(){that.expand()})
             .append(
         $('<span/>').text('Expand')
             .addClass('ui-icon')
             .addClass('ui-icon-plus')
         );
 
         // open in pager
         var morelink=$('<a/>').attr('href',"#")
             .attr('role',"button")
             .addClass('ui-button');
         var morespan=$('<span/>').text('Open in Pager')
             .addClass('ui-icon')
             .addClass('ui-icon-arrowstop-l-n');
         morelink.append(morespan);
         morelink.click(function(){
             that.showInPager();
         });
 
         // close the tooltip
         var closelink=$('<a/>').attr('href',"#");
             closelink.attr('role',"button");
             closelink.addClass('ui-button');
         var closespan=$('<span/>').text('Close');
             closespan.addClass('ui-icon');
             closespan.addClass('ui-icon-close');
         closelink.append(closespan);
         closelink.click(function(){
         that.remove_and_cancel_tooltip(true);
             });
 
         //construct the tooltip
         // add in the reverse order you want them to appear
         this.buttons.append(closelink);
         this.buttons.append(expandlink);
         this.buttons.append(morelink);
 
         // we need a phony element to make the small arrow
         // of the tooltip in css
         // we will move the arrow later
         this.arrow = $('<div/>').addClass('pretooltiparrow');
         this.tooltip.append(this.buttons);
         this.tooltip.append(this.arrow);
         this.tooltip.append(this.text);
     };
 
-    // will resend the request on behalf on the cell which invoked the tooltip
-    // to show in it in pager. This is done so to be sure of having the same
-    // result as invoking `something?`
     Tooltip.prototype.showInPager = function()
     {
          var that = this;
          var callbacks = {'execute_reply': $.proxy(that._handle_execute_reply,that)}
          var msg_id = IPython.notebook.kernel.execute(this.name+"?", callbacks);
 
          this.remove_and_cancel_tooltip();
          this._cmfocus();
     }
 
     // grow the tooltip verticaly
     Tooltip.prototype.expand = function(){
         this.text.removeClass('smalltooltip');
         this.text.addClass('bigtooltip');
         $('#expanbutton').addClass('hidden');
         this._cmfocus();
     }
 
     // deal with all the logic of hiding the tooltip
     // and reset it's status
     Tooltip.prototype.hide = function()
     {
          this.tooltip.addClass('hide');
          $('#expanbutton').removeClass('hidden');
          this.text.removeClass('bigtooltip');
          this.text.addClass('smalltooltip');
          // keep scroll top to be sure to always see the first line
          this.text.scrollTop(0);
          this._hidden = true;
     }
 
     Tooltip.prototype.remove_and_cancel_tooltip = function(force) {
         // note that we don't handle closing directly inside the calltip
         // as in the completer, because it is not focusable, so won't
         // get the event.
         if(this._sticky == false || force == true)
         {
             this.hide();
         }
         this.cancel_pending();
         this._old_cell = null ;
         this._old_request = null ;
         this._consecutive_conter = 0;
     }
 
     // cancel autocall done after '(' for example.
     Tooltip.prototype.cancel_pending = function(){
         if (this.tooltip_timeout != null){
             clearTimeout(this.tooltip_timeout);
             this.tooltip_timeout = null;
         }
     }
 
     // will trigger tooltip after timeout
     Tooltip.prototype.pending = function(cell,text)
     {
         var that = this;
         this.tooltip_timeout = setTimeout(function(){that.request(cell)} , that.time_before_tooltip);
     }
 
     // make an imediate completion request
     Tooltip.prototype.request = function(cell)
     {
         this.cancel_pending();
         var editor = cell.code_mirror;
         this.code_mirror = editor;
         var cursor = editor.getCursor();
         var text = editor.getRange({line:cursor.line,ch:0},cursor).trim();
 
         if( this._old_cell == cell && this._old_request == text && this._hidden == false)
         {
             this._consecutive_conter = this._consecutive_conter +1;
         } else {
             this._old_cell = cell ;
             this._old_request = text ;
             this._consecutive_conter =0;
             this.cancel_stick();
         }
 
         if( this._consecutive_conter == 1 )
         {
             this.expand()
             return;
         }
         else if( this._consecutive_conter ==  2)
         {
             this.stick();
             return;
         }
         else if( this._consecutive_conter ==  3)
         {
             this._old_cell = null ;
             this.cancel_stick();
             this._old_request = null ;
             this._consecutive_conter = 0;
             this.showInPager();
             this._cmfocus();
             return;
         }
         else if( this._consecutive_conter ==  4)
         {
 
         }
 
         if (text === "" || text === "(" ) {
             return;
             // don't do anything if line beggin with '(' or is empty
         }
         cell.request_tooltip(text);
     }
 
     // cancel the option of having the tooltip to stick
     Tooltip.prototype.cancel_stick = function()
     {
             clearTimeout(this._stick_timeout);
             this._sticky = false;
     }
 
     // put the tooltip in a sicky state for 10 seconds
     // it won't be removed by remove_and_cancell() unless you called with
     // the first parameter set to true.
     // remove_and_cancell_tooltip(true)
     Tooltip.prototype.stick = function()
     {
         var that = this;
         this._sticky = true;
         this._stick_timeout = setTimeout( function(){
             that._sticky = false;
             }, 10*1000
         );
     }
 
     // should be called with the kernel reply to actually show the tooltip
     Tooltip.prototype.show = function(reply, codecell)
     {
         // move the bubble if it is not hidden
         // otherwise fade it
         var editor = codecell.code_mirror;
         this.name = reply.name;
         this.code_mirror = editor;
 
         // do some math to have the tooltip arrow on more or less on left or right
         // width of the editor
         var w= $(this.code_mirror.getScrollerElement()).width();
         // ofset of the editor
         var o= $(this.code_mirror.getScrollerElement()).offset();
         var pos = editor.cursorCoords();
         var xinit = pos.x;
         var xinter = o.left + (xinit-o.left)/w*(w-450);
         var posarrowleft = xinit - xinter;
 
 
         if( this._hidden == false)
         {
             this.tooltip.animate({'left' : xinter-30+'px','top' :(pos.yBot+10)+'px'});
         } else
         {
             this.tooltip.css({'left' : xinter-30+'px'});
             this.tooltip.css({'top' :(pos.yBot+10)+'px'});
         }
         this.arrow.animate({'left' : posarrowleft+'px'});
         this.tooltip.removeClass('hidden')
         this.tooltip.removeClass('hide');
         this._hidden = false;
 
         // build docstring
         defstring = reply.call_def;
         if (defstring == null) { defstring = reply.init_definition; }
         if (defstring == null) { defstring = reply.definition; }
 
         docstring = reply.call_docstring;
         if (docstring == null) { docstring = reply.init_docstring; }
         if (docstring == null) { docstring = reply.docstring; }
         if (docstring == null) { docstring = "<empty docstring>"; }
 
         this.text.children().remove();
 
         var pre=$('<pre/>').html(utils.fixConsole(docstring));
         if(defstring){
             var defstring_html = $('<pre/>').html(utils.fixConsole(defstring));
             this.text.append(defstring_html);
         }
         this.text.append(pre);
         // keep scroll top to be sure to always see the first line
         this.text.scrollTop(0);
     }
 
     // convenient funciton to have the correct codemirror back into focus
     Tooltip.prototype._cmfocus = function()
     {
         var cm = this.code_mirror;
         setTimeout(function(){cm.focus();}, 50);
     }
 
     IPython.Tooltip = Tooltip;
     return IPython;
 }(IPython));