planetstack/core/xoslib/static/xsh/xsh.js

   1 // TryMongo
   2 //
   3 // Copyright (c) 2009 Kyle Banker
   4 // Licensed under the MIT Licence.
   5 // http://www.opensource.org/licenses/mit-license.php
   6
   7 // Readline class to handle line input.
   8 var ReadLine = function(options) {
   9   this.options      = options || {};
  10   this.htmlForInput = this.options.htmlForInput;
  11   this.inputHandler = this.options.handler || this.mockHandler;
  12   this.scoper       = this.options.scoper;
  13   this.terminal     = $(this.options.terminalId || "#terminal");
  14   this.lineClass    = this.options.lineClass || '.readLine';
  15   this.history      = [];
  16   this.historyPtr   = 0;
  17
  18   this.initialize();
  19 };
  20
  21 ReadLine.prototype = {
  22
  23   initialize: function() {
  24     this.addInputLine();
  25   },
  26
  27   // Enter a new input line with proper behavior.
  28   addInputLine: function(stackLevel) {
  29     stackLevel = stackLevel || 0;
  30     this.terminal.append(this.htmlForInput(stackLevel));
  31     var ctx = this;
  32     ctx.activeLine = $(this.lineClass + '.active');
  33
  34     // Bind key events for entering and navigting history.
  35     ctx.activeLine.bind("keydown", function(ev) {
  36       switch (ev.keyCode) {
  37         case EnterKeyCode:
  38           ctx.processInput(this.value);
  39           break;
  40         case UpArrowKeyCode:
  41           ctx.getCommand('previous');
  42           break;
  43         case DownArrowKeyCode:
  44           ctx.getCommand('next');
  45           break;
  46       }
  47     });
  48
  49     this.activeLine.focus();
  50   },
  51
  52   // Returns the 'next' or 'previous' command in this history.
  53   getCommand: function(direction) {
  54     if(this.history.length === 0) {
  55       return;
  56     }
  57     this.adjustHistoryPointer(direction);
  58     this.activeLine[0].value = this.history[this.historyPtr];
  59     $(this.activeLine[0]).focus();
  60     //this.activeLine[0].value = this.activeLine[0].value;
  61   },
  62
  63   // Moves the history pointer to the 'next' or 'previous' position.
  64   adjustHistoryPointer: function(direction) {
  65     if(direction == 'previous') {
  66       if(this.historyPtr - 1 >= 0) {
  67         this.historyPtr -= 1;
  68       }
  69     }
  70     else {
  71       if(this.historyPtr + 1 < this.history.length) {
  72         this.historyPtr += 1;
  73       }
  74     }
  75   },
  76
  77   // Return the handler's response.
  78   processInput: function(value) {
  79     var response = this.inputHandler.apply(this.scoper, [value]);
  80     this.insertResponse(response.result);
  81
  82     // Save to the command history...
  83     if((lineValue = value.trim()) !== "") {
  84       this.history.push(lineValue);
  85       this.historyPtr = this.history.length;
  86     }
  87
  88     // deactivate the line...
  89     this.activeLine.value = "";
  90     this.activeLine.attr({disabled: true});
  91     this.activeLine.removeClass('active');
  92
  93     // and add add a new command line.
  94     this.addInputLine(response.stack);
  95   },
  96
  97   insertResponse: function(response) {
  98     if((response.length < 1) || (response=='"donotprintme"') || (response=='donotprintme')) {
  99       this.activeLine.parent().append("<p class='response'></p>");
 100     }
 101     else {
 102       this.activeLine.parent().append("<p class='response'>" + response + "</p>");
 103     }
 104   },
 105
 106   // Simply return the entered string if the user hasn't specified a smarter handler.
 107   mockHandler: function(inputString) {
 108     return function() {
 109       this._process = function() { return inputString; };
 110     };
 111   }
 112 };
 113
 114 var MongoHandler = function() {
 115   this._currentCommand = "";
 116   this._rawCommand     = "";
 117   this._commandStack   = 0;
 118   this._tutorialPtr    = 0;
 119   this._tutorialMax    = 4;
 120
 121   this._mongo          = {};
 122   this._mongo.test     = [];
 123   this.collections     = [];
 124 };
 125
 126 MongoHandler.prototype = {
 127
 128   _process: function(inputString, errorCheck) {
 129     this._rawCommand += ' ' + inputString;
 130
 131     try {
 132       inputString += '  '; // fixes certain bugs with the tokenizer.
 133       var tokens    = inputString.tokens();
 134       var mongoFunc = this._getCommand(tokens);
 135       if(this._commandStack === 0 && inputString.match(/^\s*$/)) {
 136         return {stack: 0, result: ''};
 137       }
 138       else if(this._commandStack === 0 && mongoFunc) {
 139         this._resetCurrentCommand();
 140         return {stack: 0, result: mongoFunc.apply(this, [tokens])};
 141       }
 142       else {
 143         return this._evaluator(tokens);
 144       }
 145     }
 146
 147     catch(err) {
 148         this._resetCurrentCommand();
 149         console.trace();
 150         return {stack: 0, result: "JS Error: " + err};
 151     }
 152   },
 153
 154   // Calls eval on the input string when ready.
 155   _evaluator: function(tokens) {
 156     isAssignment = tokens.length>=2 && tokens[0].type=="name" && tokens[1].type=="operator" && tokens[1].value=="=";
 157
 158     this._currentCommand += " " + this._massageTokens(tokens);
 159     if(this._shouldEvaluateCommand(tokens))  {
 160         print = this.print;
 161
 162         // So this eval statement is the heart of the REPL.
 163         var result = eval(this._currentCommand.trim());
 164         if(result === undefined) {
 165           throw('result is undefined');
 166         } else if (typeof(result) === 'function') {
 167           throw('result is a function. did you mean to call it?');
 168         } else {
 169           result = $htmlFormat(result);
 170         }
 171         this._resetCurrentCommand();
 172         if (isAssignment) {
 173             return {stack: this._commandStack, result: ""};
 174         } else {
 175             return {stack: this._commandStack, result: result};
 176         }
 177       }
 178
 179     else {
 180       return {stack: this._commandStack, result: ""};
 181     }
 182   },
 183
 184   _resetCurrentCommand: function() {
 185     this._currentCommand = '';
 186     this._rawCommand     = '';
 187   },
 188
 189   // Evaluate only when we've exited any blocks.
 190   _shouldEvaluateCommand: function(tokens) {
 191     for(var i=0; i < tokens.length; i++) {
 192       var token = tokens[i];
 193       if(token.type == 'operator') {
 194         if(token.value == '(' || token.value == '{') {
 195           this._commandStack += 1;
 196         }
 197         else if(token.value == ')' || token.value == '}') {
 198           this._commandStack -= 1;
 199         }
 200       }
 201     }
 202
 203     if(this._commandStack === 0) {
 204       return true;
 205     }
 206     else {
 207       return false;
 208     }
 209   },
 210
 211   _massageTokens: function(tokens) {
 212     for(var i=0; i < tokens.length; i++) {
 213       if(tokens[i].type == 'name') {
 214         if(tokens[i].value == 'var') {
 215           tokens[i].value = '';
 216         }
 217       }
 218     }
 219     return this._collectTokens(tokens);
 220   },
 221
 222   // Collects tokens into a string, placing spaces between variables.
 223   // This methods is called after we scope the vars.
 224   _collectTokens: function(tokens) {
 225     var result = "";
 226     for(var i=0; i < tokens.length; i++) {
 227       if(tokens[i].type == "name" && tokens[i+1] && tokens[i+1].type == 'name') {
 228         result += tokens[i].value + ' ';
 229       }
 230       else if (tokens[i].type == 'string') {
 231         result += "'" + tokens[i].value + "'";
 232       }
 233       else {
 234         result += tokens[i].value;
 235       }
 236     }
 237     return result;
 238   },
 239
 240   // print output to the screen, e.g., in a loop
 241   // TODO: remove dependency here
 242   print: function() {
 243    $('.readLine.active').parent().append('<p>' + JSON.stringify(arguments[0]) + '</p>');
 244    return "donotprintme";
 245   },
 246
 247   /* MongoDB     */
 248   /* ________________________________________ */
 249
 250   // help command
 251   _help: function() {
 252       return PTAG('HELP') +
 253              PTAG('xos                                 list xos API object types') +
 254              PTAG('xos.slices.fetch()                  fetch slices from the server') +
 255              PTAG('xos.slices                          get the slices that were fetched');
 256
 257   },
 258
 259   _tutorial: function() {
 260     this._tutorialPtr = 0;
 261     return PTAG("This is a self-guided tutorial on the xos shell.") +
 262            PTAG("The tutorial is simple, more or less a few basic commands to try.") +
 263            PTAG("To go directly to any part tutorial, enter one of the commands t0, t1, t2...t10") +
 264            PTAG("Otherwise, use 'next' and 'back'. Start by typing 'next' and pressing enter.");
 265   },
 266
 267   // go to the next step in the tutorial.
 268   _next: function() {
 269     if(this._tutorialPtr < this._tutorialMax) {
 270       return this['_t' + (this._tutorialPtr + 1)]();
 271     }
 272     else {
 273       return "You've reached the end of the tutorial. To go to the beginning, type 'tutorial'";
 274     }
 275   },
 276
 277   // go to the previous step in the tutorial.
 278   _back: function() {
 279     if(this._tutorialPtr > 1) {
 280       return this['_t' + (this._tutorialPtr - 1)]();
 281     }
 282     else {
 283       return this._tutorial();
 284     }
 285   },
 286
 287   _t1: function() {
 288     this._tutorialPtr = 1;
 289     return PTAG('1. JavaScript Shell') +
 290            PTAG('The first thing to notice is that the MongoDB shell is JavaScript-based.') +
 291            PTAG('So you can do things like:') +
 292            PTAG('  a = 5; ') +
 293            PTAG('  a * 10; ') +
 294            PTAG('  print(a); ') +
 295            PTAG("  for(i=0; i<10; i++) { print('hello'); }; ") +
 296            PTAG("Try a few JS commands; when you're ready to move on, enter 'next'");
 297
 298   },
 299
 300   _t2: function() {
 301     this._tutorialPtr = 2;
 302     return PTAG('2. Reading from the server is asynchronous') +
 303            PTAG('Try these:') +
 304            PTAG('    xos.slices.models;') +
 305            PTAG('    // the above should have printed empty list') +
 306            PTAG('    xos.slices.fetch();') +
 307            PTAG('    // wait a second or two...') +
 308            PTAG('    xos.slices.models;');
 309
 310   },
 311
 312   _t3: function() {
 313     this._tutorialPtr = 3;
 314     return PTAG('3. Responding to events') +
 315            PTAG('Try these:') +
 316            PTAG('    xos.slices.fetch();') +
 317            PTAG('    tmp=xos.slices.on("change", function() { alert("woot!"); });') +
 318            PTAG('    xos.slices.models[0].set("description", "somerandomtext");');
 319
 320   },
 321
 322   _t4: function() {
 323     this._tutorialPtr = 4;
 324     return PTAG('4. Available xos objects and methods') +
 325            PTAG('Try these:') +
 326            PTAG('    xos.listObjects();') +
 327            PTAG('    xos.slices.listMethods();');
 328
 329   },
 330
 331   _getCommand: function(tokens) {
 332     if(tokens[0] && ArrayInclude(MongoKeywords,(tokens[0].value + '').toLowerCase())) {
 333       switch(tokens[0].value.toLowerCase()) {
 334         case 'help':
 335           return this._help;
 336
 337         case 'tutorial':
 338           return this._tutorial;
 339         case 'next':
 340           return this._next;
 341         case 'back':
 342           return this._back;
 343         case 't0':
 344           return this._tutorial;
 345         case 't1':
 346           return this._t1;
 347         case 't2':
 348           return this._t2;
 349         case 't3':
 350           return this._t3;
 351         case 't4':
 352           return this._t4;
 353       }
 354     }
 355   }
 356 };
 357
 358 function replaceAll(find, replace, str) {
 359   return str.replace(new RegExp(find, 'g'), replace);\r
 360 }
 361
 362 /* stackoverflow: http://stackoverflow.com/questions/4810841/how-can-i-pretty-print-json-using-javascript */
 363 function syntaxHighlight(json) {
 364     if ( json.hasOwnProperty("__str__")) {
 365         return syntaxHighlight(json.__str__());
 366     }
 367     if (typeof json != 'string') {\r
 368          json = JSON.stringify(json, undefined, "\t");\r
 369     }\r
 370     json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\r
 371     return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {\r
 372         var cls = 'terminal_number';\r
 373         if (/^"/.test(match)) {\r
 374             if (/:$/.test(match)) {\r
 375                 cls = 'terminal_key';\r
 376             } else {\r
 377                 cls = 'terminal_string';\r
 378             }\r
 379         } else if (/true|false/.test(match)) {\r
 380             cls = 'terminal_boolean';\r
 381         } else if (/null/.test(match)) {\r
 382             cls = 'terminal_null';\r
 383         }\r
 384         return '<span class="' + cls + '">' + match + '</span>';\r
 385     });\r
 386 }
 387
 388 $htmlFormat = function(obj) {
 389   //JSON.stringify(obj,undefined,2)
 390   result=replaceAll("\t","&nbsp;",replaceAll("\n","<br>",syntaxHighlight(obj))); //tojson(obj, ' ', ' ', true);
 391   return result;
 392 }
 393
 394 function startTerminal() {
 395   var mongo       = new MongoHandler();
 396   var terminal    = new ReadLine({htmlForInput: DefaultInputHtml,
 397                                   handler: mongo._process,
 398                                   scoper: mongo});
 399   $("#terminal_help1").show();
 400   $("#terminal_help2").show();
 401   $("#terminal_wait").hide();
 402
 403   $("#terminal").bind('click', function() { $(".readLine.active").focus(); });
 404 };
 405
 406 $(document).ready(function() {
 407     startTerminal();
 408 });