js/source/legacy/jquery/dstk.js

   1 /*
   2  * jQuery Data Science Toolkit Plugin
   3  * version: 0.50 (2013-05-19)
   4  *
   5  * Example:
   6  *   var dstk = $.DSTK();
   7  *   dstk.street2coordinates('2543 Graystone Place, Simi Valley, CA 93065', myCallback);
   8  *
   9  * See http://www.datasciencetoolkit.org/developerdocs#javascript for a full
  10  * guide on how to use this interface.
  11  *
  12  * This jQuery plugin is a simple way to access the Data Science Toolkit
  13  * from Javascript. It's designed to work well cross-domain, using JSONP
  14  * calls. The only restriction is that the text-handling calls can't take
  15  * inputs of more than about 8k characters if going across domains, since
  16  * they're limited to the length of a URL. You can work around this either
  17  * by running your own copy of the server (it's available as a free VM and
  18  * Amazon EC2 image) or just using a proxy from your domain.
  19  *
  20  * All code (C) Pete Warden, 2011
  21  *
  22  *    This program is free software: you can redistribute it and/or modify
  23  *    it under the terms of the GNU General Public License as published by
  24  *    the Free Software Foundation, either version 3 of the License, or
  25  *    (at your option) any later version.
  26  *
  27  *    This program is distributed in the hope that it will be useful,
  28  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  29  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30  *    GNU General Public License for more details.
  31  *
  32  *    You should have received a copy of the GNU General Public License
  33  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  34  *
  35  */
  36
  37 (function($) {
  38
  39   // Call this to create a new Data Science Toolkit object, that you can then
  40   // use to make API calls.
  41   $.DSTK = function(options) {
  42
  43     if ((typeof options == 'undefined')||(options == null)) {
  44       options = {};
  45     }
  46
  47     // These are the only dependencies on JQuery. If you want to run the code without
  48     // the framework, you can replace them with matching functions and call the
  49     // constructor directly, eg
  50     // var dstk = new DSTK({ajaxFunction: myAjax, toJSONFunction: myToJSON});
  51     options.ajaxFunction = $.ajax;
  52     options.toJSONFunction = $.toJSON;
  53
  54     return new DSTK(options);
  55   };
  56 })(jQuery);
  57
  58 function DSTK(options) {
  59
  60   var defaultOptions = {
  61     apiBase: 'http://www.datasciencetoolkit.org',
  62     checkVersion: true
  63   };
  64
  65   if ((typeof options == 'undefined')||(options == null)) {
  66     options = defaultOptions;
  67   } else {
  68     for (var key in defaultOptions) {
  69       if (typeof options[key]=='undefined') {
  70         options[key] = defaultOptions[key];
  71       }
  72     }
  73   }
  74
  75   this.apiBase = options.apiBase;
  76   this.ajaxFunction = options.ajaxFunction;
  77   this.toJSONFunction = options.toJSONFunction;
  78
  79   if (options.checkVersion) {
  80     this.checkVersion();
  81   }
  82 }
  83
  84 DSTK.prototype.checkVersion = function() {
  85
  86   var requiredVersion = 50;
  87
  88   var apiUrl = this.apiBase+'/info';
  89
  90   this.ajaxFunction(apiUrl, {
  91     success: function(result) {
  92       var actualVersion = result['version'];
  93       if (actualVersion<requiredVersion) {
  94         throw 'DSTK: Version '+actualVersion+' found at "'+apiUrl+'" but '+requiredVersion+' is required';
  95       }
  96     },
  97     dataType: 'jsonp',
  98     crossDomain: true
  99   });
 100
 101 };
 102
 103 // See http://www.datasciencetoolkit.org/developerdocs for information on these calls
 104
 105 DSTK.prototype.ip2coordinates = function(ips, callback) {
 106
 107   if (typeof ips.length == 'undefined') {
 108     ips = [ips];
 109   }
 110
 111   var apiUrl = this.apiBase+'/ip2coordinates';
 112   apiUrl += '/'+encodeURIComponent($.toJSON(ips));
 113
 114   this.ajaxFunction(apiUrl, {
 115     success: callback,
 116     dataType: 'jsonp',
 117     crossDomain: true
 118   });
 119 };
 120
 121 DSTK.prototype.street2coordinates = function(addresses, callback) {
 122
 123   if (typeof addresses.length == 'undefined') {
 124     addresses = [addresses];
 125   }
 126
 127   var apiUrl = this.apiBase+'/street2coordinates';
 128   apiUrl += '/'+encodeURIComponent($.toJSON(addresses));
 129
 130   $.ajax(apiUrl, {
 131     success: callback,
 132     dataType: 'jsonp',
 133     crossDomain: true
 134   });
 135 };
 136
 137 DSTK.prototype.coordinates2politics = function(coordinates, callback) {
 138
 139   if (typeof coordinates.length == 'undefined') {
 140     coordinates = [coordinates];
 141   }
 142
 143   var apiUrl = this.apiBase+'/coordinates2politics';
 144   apiUrl += '/'+encodeURIComponent($.toJSON(coordinates));
 145
 146   $.ajax(apiUrl, {
 147     success: callback,
 148     dataType: 'jsonp',
 149     crossDomain: true
 150   });
 151 };
 152
 153 DSTK.prototype.text2places = function(text, callback) {
 154   this.makeTextCall(text, callback, 'text2places');
 155 };
 156
 157 DSTK.prototype.text2sentences = function(text, callback) {
 158   this.makeTextCall(text, callback, 'text2sentences');
 159 };
 160
 161 DSTK.prototype.html2text = function(html, callback) {
 162   this.makeTextCall(html, callback, 'html2text');
 163 };
 164
 165 DSTK.prototype.html2story = function(html, callback) {
 166   this.makeTextCall(html, callback, 'html2story');
 167 };
 168
 169 DSTK.prototype.text2people = function(text, callback) {
 170   this.makeTextCall(text, callback, 'text2people');
 171 };
 172
 173 DSTK.prototype.text2times = function(text, callback) {
 174   this.makeTextCall(text, callback, 'text2times');
 175 };
 176
 177 DSTK.prototype.googlestylegeocoder = function(address, callback) {
 178   var apiUrl = this.apiBase+'/maps/api/geocode/json';
 179   apiUrl += '?address='+encodeURIComponent(address);
 180   $.ajax(apiUrl, {
 181     success: callback,
 182     dataType: 'jsonp',
 183     crossDomain: true
 184   });
 185 };
 186
 187 DSTK.prototype.text2sentiment = function(text, callback) {
 188   this.makeTextCall(text, callback, 'text2sentiment');
 189 };
 190
 191 DSTK.prototype.coordinates2statistics = function(coordinates, callback) {
 192
 193   if (typeof coordinates.length == 'undefined') {
 194     coordinates = [coordinates];
 195   }
 196
 197   var apiUrl = this.apiBase+'/coordinates2statistics';
 198   apiUrl += '/'+encodeURIComponent($.toJSON(coordinates));
 199
 200   $.ajax(apiUrl, {
 201     success: callback,
 202     dataType: 'jsonp',
 203     crossDomain: true
 204   });
 205 };
 206
 207 DSTK.prototype.makeTextCall = function(text, callback, method) {
 208
 209   var apiUrl = this.apiBase+'/'+method;
 210   var apiSuffix = encodeURIComponent($.toJSON([text]));
 211
 212   if (apiSuffix.length<7500) {
 213     apiUrl += '/'+apiSuffix;
 214
 215     $.ajax(apiUrl, {
 216       success: callback,
 217       dataType: 'jsonp',
 218       crossDomain: true
 219     });
 220   } else {
 221
 222     $.ajax({
 223       url: apiUrl,
 224       data: text,
 225       success: callback,
 226       dataType: 'json',
 227       type: 'POST',
 228       crossDomain: true
 229     });
 230
 231   }
 232 };
 233
 234
 235 /*
 236  * jQuery JSON Plugin
 237  * version: 2.1 (2009-08-14)
 238  *
 239  * This document is licensed as free software under the terms of the
 240  * MIT License: http://www.opensource.org/licenses/mit-license.php
 241  *
 242  * Brantley Harris wrote this plugin. It is based somewhat on the JSON.org
 243  * website's http://www.json.org/json2.js, which proclaims:
 244  * "NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.", a sentiment that
 245  * I uphold.
 246  *
 247  * It is also influenced heavily by MochiKit's serializeJSON, which is
 248  * copyrighted 2005 by Bob Ippolito.
 249  */
 250
 251 (function($) {
 252     /** jQuery.toJSON( json-serializble )
 253         Converts the given argument into a JSON respresentation.
 254
 255         If an object has a "toJSON" function, that will be used to get the representation.
 256         Non-integer/string keys are skipped in the object, as are keys that point to a function.
 257
 258         json-serializble:
 259             The *thing* to be converted.
 260      **/
 261     $.toJSON = function(o)
 262     {
 263         if (typeof(JSON) == 'object' && JSON.stringify)
 264             return JSON.stringify(o);
 265
 266         var type = typeof(o);
 267
 268         if (o === null)
 269             return "null";
 270
 271         if (type == "undefined")
 272             return undefined;
 273
 274         if (type == "number" || type == "boolean")
 275             return o + "";
 276
 277         if (type == "string")
 278             return $.quoteString(o);
 279
 280         if (type == 'object')
 281         {
 282             if (typeof o.toJSON == "function")
 283                 return $.toJSON( o.toJSON() );
 284
 285             if (o.constructor === Date)
 286             {
 287                 var month = o.getUTCMonth() + 1;
 288                 if (month < 10) month = '0' + month;
 289
 290                 var day = o.getUTCDate();
 291                 if (day < 10) day = '0' + day;
 292
 293                 var year = o.getUTCFullYear();
 294
 295                 var hours = o.getUTCHours();
 296                 if (hours < 10) hours = '0' + hours;
 297
 298                 var minutes = o.getUTCMinutes();
 299                 if (minutes < 10) minutes = '0' + minutes;
 300
 301                 var seconds = o.getUTCSeconds();
 302                 if (seconds < 10) seconds = '0' + seconds;
 303
 304                 var milli = o.getUTCMilliseconds();
 305                 if (milli < 100) milli = '0' + milli;
 306                 if (milli < 10) milli = '0' + milli;
 307
 308                 return '"' + year + '-' + month + '-' + day + 'T' +
 309                              hours + ':' + minutes + ':' + seconds +
 310                              '.' + milli + 'Z"';
 311             }
 312
 313             if (o.constructor === Array)
 314             {
 315                 var ret = [];
 316                 for (var i = 0; i < o.length; i++)
 317                     ret.push( $.toJSON(o[i]) || "null" );
 318
 319                 return "[" + ret.join(",") + "]";
 320             }
 321
 322             var pairs = [];
 323             for (var k in o) {
 324                 var name;
 325                 var type = typeof k;
 326
 327                 if (type == "number")
 328                     name = '"' + k + '"';
 329                 else if (type == "string")
 330                     name = $.quoteString(k);
 331                 else
 332                     continue;  //skip non-string or number keys
 333
 334                 if (typeof o[k] == "function")
 335                     continue;  //skip pairs where the value is a function.
 336
 337                 var val = $.toJSON(o[k]);
 338
 339                 pairs.push(name + ":" + val);
 340             }
 341
 342             return "{" + pairs.join(", ") + "}";
 343         }
 344     };
 345
 346     /** jQuery.evalJSON(src)
 347         Evaluates a given piece of json source.
 348      **/
 349     $.evalJSON = function(src)
 350     {
 351         if (typeof(JSON) == 'object' && JSON.parse)
 352             return JSON.parse(src);
 353         return eval("(" + src + ")");
 354     };
 355
 356     /** jQuery.secureEvalJSON(src)
 357         Evals JSON in a way that is *more* secure.
 358     **/
 359     $.secureEvalJSON = function(src)
 360     {
 361         if (typeof(JSON) == 'object' && JSON.parse)
 362             return JSON.parse(src);
 363
 364         var filtered = src;
 365         filtered = filtered.replace(/\\["\\\/bfnrtu]/g, '@');
 366         filtered = filtered.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
 367         filtered = filtered.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
 368
 369         if (/^[\],:{}\s]*$/.test(filtered))
 370             return eval("(" + src + ")");
 371         else
 372             throw new SyntaxError("Error parsing JSON, source is not valid.");
 373     };
 374
 375     /** jQuery.quoteString(string)
 376         Returns a string-repr of a string, escaping quotes intelligently.
 377         Mostly a support function for toJSON.
 378
 379         Examples:
 380             >>> jQuery.quoteString("apple")
 381             "apple"
 382
 383             >>> jQuery.quoteString('"Where are we going?", she asked.')
 384             "\"Where are we going?\", she asked."
 385      **/
 386     $.quoteString = function(string)
 387     {
 388         if (string.match(_escapeable))
 389         {
 390             return '"' + string.replace(_escapeable, function (a)
 391             {
 392                 var c = _meta[a];
 393                 if (typeof c === 'string') return c;
 394                 c = a.charCodeAt();
 395                 return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16);
 396             }) + '"';
 397         }
 398         return '"' + string + '"';
 399     };
 400
 401     var _escapeable = /["\\\x00-\x1f\x7f-\x9f]/g;
 402
 403     var _meta = {
 404         '\b': '\\b',
 405         '\t': '\\t',
 406         '\n': '\\n',
 407         '\f': '\\f',
 408         '\r': '\\r',
 409         '"' : '\\"',
 410         '\\': '\\\\'
 411     };
 412 })(jQuery);