planetstack/core/static/shell/opencloud_shell.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         opencloud = new OpenCloud();
 161         print = this.print;
 162
 163         // So this eval statement is the heart of the REPL.
 164         var result = eval(this._currentCommand.trim());
 165         if(result === undefined) {
 166           throw('result is undefined');
 167         } else {
 168           result = $htmlFormat(result);
 169         }
 170         this._resetCurrentCommand();
 171         if (isAssignment) {
 172             return {stack: this._commandStack, result: ""};
 173         } else {
 174             return {stack: this._commandStack, result: result};
 175         }
 176       }
 177
 178     else {
 179       return {stack: this._commandStack, result: ""};
 180     }
 181   },
 182
 183   _resetCurrentCommand: function() {
 184     this._currentCommand = '';
 185     this._rawCommand     = '';
 186   },
 187
 188   // Evaluate only when we've exited any blocks.
 189   _shouldEvaluateCommand: function(tokens) {
 190     for(var i=0; i < tokens.length; i++) {
 191       var token = tokens[i];
 192       if(token.type == 'operator') {
 193         if(token.value == '(' || token.value == '{') {
 194           this._commandStack += 1;
 195         }
 196         else if(token.value == ')' || token.value == '}') {
 197           this._commandStack -= 1;
 198         }
 199       }
 200     }
 201
 202     if(this._commandStack === 0) {
 203       return true;
 204     }
 205     else {
 206       return false;
 207     }
 208   },
 209
 210   _massageTokens: function(tokens) {
 211     for(var i=0; i < tokens.length; i++) {
 212       if(tokens[i].type == 'name') {
 213         if(tokens[i].value == 'var') {
 214           tokens[i].value = '';
 215         }
 216       }
 217     }
 218     return this._collectTokens(tokens);
 219   },
 220
 221   // Collects tokens into a string, placing spaces between variables.
 222   // This methods is called after we scope the vars.
 223   _collectTokens: function(tokens) {
 224     var result = "";
 225     for(var i=0; i < tokens.length; i++) {
 226       if(tokens[i].type == "name" && tokens[i+1] && tokens[i+1].type == 'name') {
 227         result += tokens[i].value + ' ';
 228       }
 229       else if (tokens[i].type == 'string') {
 230         result += "'" + tokens[i].value + "'";
 231       }
 232       else {
 233         result += tokens[i].value;
 234       }
 235     }
 236     return result;
 237   },
 238
 239   // print output to the screen, e.g., in a loop
 240   // TODO: remove dependency here
 241   print: function() {
 242    $('.readLine.active').parent().append('<p>' + JSON.stringify(arguments[0]) + '</p>');
 243    return "donotprintme";
 244   },
 245
 246   /* MongoDB     */
 247   /* ________________________________________ */
 248
 249   // help command
 250   _help: function() {
 251       return PTAG('HELP') +
 252              PTAG('opencloud                                 list opencloud API object types') +
 253              PTAG('opencloud.slices                          list methods to can call on slices') +
 254              PTAG('opencloud.slices.all()                    get all slices') +
 255              PTAG('opencloud.slices.filter({key: "value"})   filter using dictionary') +
 256              PTAG('opencloud.slices.get({key: "value"}))     get using dictionary')
 257
 258   },
 259
 260   _tutorial: function() {
 261     this._tutorialPtr = 0;
 262     return PTAG("This is a self-guided tutorial on the OpenCloud shell.") +
 263            PTAG("The tutorial is simple, more or less a few basic commands to try.") +
 264            PTAG("To go directly to any part tutorial, enter one of the commands t0, t1, t2...t10") +
 265            PTAG("Otherwise, use 'next' and 'back'. Start by typing 'next' and pressing enter.");
 266   },
 267
 268   // go to the next step in the tutorial.
 269   _next: function() {
 270     if(this._tutorialPtr < this._tutorialMax) {
 271       return this['_t' + (this._tutorialPtr + 1)]();
 272     }
 273     else {
 274       return "You've reached the end of the tutorial. To go to the beginning, type 'tutorial'";
 275     }
 276   },
 277
 278   // go to the previous step in the tutorial.
 279   _back: function() {
 280     if(this._tutorialPtr > 1) {
 281       return this['_t' + (this._tutorialPtr - 1)]();
 282     }
 283     else {
 284       return this._tutorial();
 285     }
 286   },
 287
 288   _t1: function() {
 289     this._tutorialPtr = 1;
 290     return PTAG('1. JavaScript Shell') +
 291            PTAG('The first thing to notice is that the MongoDB shell is JavaScript-based.') +
 292            PTAG('So you can do things like:') +
 293            PTAG('  a = 5; ') +
 294            PTAG('  a * 10; ') +
 295            PTAG('  print(a); ') +
 296            PTAG("  for(i=0; i<10; i++) { print('hello'); }; ") +
 297            PTAG("Try a few JS commands; when you're ready to move on, enter 'next'");
 298
 299   },
 300
 301   _t2: function() {
 302     this._tutorialPtr = 2;
 303     return PTAG('2. List some objects') +
 304            PTAG('Try these:') +
 305            PTAG('    opencloud.slices.all();') +
 306            PTAG('    opencloud.slivers.all();') +
 307            PTAG('    opencloud.sites.all();') +
 308            PTAG('    opencloud.nodes.all();');
 309
 310   },
 311
 312   _t3: function() {
 313     this._tutorialPtr = 3;
 314     return PTAG('3. Filter some objects') +
 315            PTAG('Try these:') +
 316            PTAG('    opencloud.slices.get({name: "HyperCache"});');
 317            PTAG('    opencloud.nodes.filter({site_id: opencloud.sites.get({name: "Princeton"})["id"]});');
 318
 319   },
 320
 321   _t4: function() {
 322     this._tutorialPtr = 4;
 323     return PTAG('4. Available OpenCloud objects and methods') +
 324            PTAG('Try these:') +
 325            PTAG('    opencloud;') +
 326            PTAG('    opencloud.nodes;');
 327
 328   },
 329
 330   _getCommand: function(tokens) {
 331     if(tokens[0] && ArrayInclude(MongoKeywords,(tokens[0].value + '').toLowerCase())) {
 332       switch(tokens[0].value.toLowerCase()) {
 333         case 'help':
 334           return this._help;
 335
 336         case 'tutorial':
 337           return this._tutorial;
 338         case 'next':
 339           return this._next;
 340         case 'back':
 341           return this._back;
 342         case 't0':
 343           return this._tutorial;
 344         case 't1':
 345           return this._t1;
 346         case 't2':
 347           return this._t2;
 348         case 't3':
 349           return this._t3;
 350         case 't4':
 351           return this._t4;
 352       }
 353     }
 354   }
 355 };
 356
 357 function replaceAll(find, replace, str) {
 358   return str.replace(new RegExp(find, 'g'), replace);\r
 359 }
 360
 361 /* stackoverflow: http://stackoverflow.com/questions/4810841/how-can-i-pretty-print-json-using-javascript */
 362 function syntaxHighlight(json) {
 363     if ( json.hasOwnProperty("__str__")) {
 364         return syntaxHighlight(json.__str__());
 365     }
 366     if (typeof json != 'string') {\r
 367          json = JSON.stringify(json, undefined, "\t");\r
 368     }\r
 369     json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\r
 370     return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {\r
 371         var cls = 'terminal_number';\r
 372         if (/^"/.test(match)) {\r
 373             if (/:$/.test(match)) {\r
 374                 cls = 'terminal_key';\r
 375             } else {\r
 376                 cls = 'terminal_string';\r
 377             }\r
 378         } else if (/true|false/.test(match)) {\r
 379             cls = 'terminal_boolean';\r
 380         } else if (/null/.test(match)) {\r
 381             cls = 'terminal_null';\r
 382         }\r
 383         return '<span class="' + cls + '">' + match + '</span>';\r
 384     });\r
 385 }
 386
 387 $htmlFormat = function(obj) {
 388   //JSON.stringify(obj,undefined,2)
 389   result=replaceAll("\t","&nbsp;",replaceAll("\n","<br>",syntaxHighlight(obj))); //tojson(obj, ' ', ' ', true);
 390   return result;
 391 }
 392
 393 function startTerminal() {
 394   var mongo       = new MongoHandler();
 395   var terminal    = new ReadLine({htmlForInput: DefaultInputHtml,
 396                                   handler: mongo._process,
 397                                   scoper: mongo});
 398   $("#terminal_help1").show();
 399   $("#terminal_help2").show();
 400   $("#terminal_wait").hide();
 401
 402   $("#terminal").bind('click', function() { $(".readLine.active").focus(); });
 403 };
 404
 405 $(document).ready(function() {
 406     updateOpenCloud(onLoaded = startTerminal);
 407 });