wradmin_/wradmin/public/yui/json/json.js

   1 /*
   2 Copyright (c) 2009, Yahoo! Inc. All rights reserved.
   3 Code licensed under the BSD License:
   4 http://developer.yahoo.net/yui/license.txt
   5 version: 2.7.0
   6 */
   7 /**
   8  * Provides methods to parse JSON strings and convert objects to JSON strings.
   9  * @module json
  10  * @class JSON
  11  * @static
  12  */
  13 YAHOO.lang.JSON = (function () {
  14
  15 var l = YAHOO.lang,
  16
  17     /**
  18      * Replace certain Unicode characters that JavaScript may handle incorrectly
  19      * during eval--either by deleting them or treating them as line
  20      * endings--with escape sequences.
  21      * IMPORTANT NOTE: This regex will be used to modify the input if a match is
  22      * found.
  23      * @property _UNICODE_EXCEPTIONS
  24      * @type {RegExp}
  25      * @private
  26      */
  27     _UNICODE_EXCEPTIONS = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
  28
  29     /**
  30      * First step in the validation.  Regex used to replace all escape
  31      * sequences (i.e. "\\", etc) with '@' characters (a non-JSON character).
  32      * @property _ESCAPES
  33      * @type {RegExp}
  34      * @static
  35      * @private
  36      */
  37     _ESCAPES = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
  38
  39     /**
  40      * Second step in the validation.  Regex used to replace all simple
  41      * values with ']' characters.
  42      * @property _VALUES
  43      * @type {RegExp}
  44      * @static
  45      * @private
  46      */
  47     _VALUES  = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
  48
  49     /**
  50      * Third step in the validation.  Regex used to remove all open square
  51      * brackets following a colon, comma, or at the beginning of the string.
  52      * @property _BRACKETS
  53      * @type {RegExp}
  54      * @static
  55      * @private
  56      */
  57     _BRACKETS = /(?:^|:|,)(?:\s*\[)+/g,
  58
  59     /**
  60      * Final step in the validation.  Regex used to test the string left after
  61      * all previous replacements for invalid characters.
  62      * @property _INVALID
  63      * @type {RegExp}
  64      * @static
  65      * @private
  66      */
  67     _INVALID  = /^[\],:{}\s]*$/,
  68
  69     /**
  70      * Regex used to replace special characters in strings for JSON
  71      * stringification.
  72      * @property _SPECIAL_CHARS
  73      * @type {RegExp}
  74      * @static
  75      * @private
  76      */
  77     _SPECIAL_CHARS = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
  78
  79     /**
  80      * Character substitution map for common escapes and special characters.
  81      * @property _CHARS
  82      * @type {Object}
  83      * @static
  84      * @private
  85      */
  86     _CHARS = {
  87         '\b': '\\b',
  88         '\t': '\\t',
  89         '\n': '\\n',
  90         '\f': '\\f',
  91         '\r': '\\r',
  92         '"' : '\\"',
  93         '\\': '\\\\'
  94     };
  95
  96 /**
  97  * Traverses nested objects, applying a filter or reviver function to
  98  * each value.  The value returned from the function will replace the
  99  * original value in the key:value pair.  If the value returned is
 100  * undefined, the key will be omitted from the returned object.
 101  * @method _revive
 102  * @param data {MIXED} Any JavaScript data
 103  * @param reviver {Function} filter or mutation function
 104  * @return {MIXED} The results of the filtered/mutated data structure
 105  * @private
 106  */
 107 function _revive(data, reviver) {
 108     var walk = function (o,key) {
 109         var k,v,value = o[key];
 110         if (value && typeof value === 'object') {
 111             for (k in value) {
 112                 if (l.hasOwnProperty(value,k)) {
 113                     v = walk(value, k);
 114                     if (v === undefined) {
 115                         delete value[k];
 116                     } else {
 117                         value[k] = v;
 118                     }
 119                 }
 120             }
 121         }
 122         return reviver.call(o,key,value);
 123     };
 124
 125     return typeof reviver === 'function' ? walk({'':data},'') : data;
 126 }
 127
 128 /**
 129  * Escapes a special character to a safe Unicode representation
 130  * @method _char
 131  * @param c {String} single character to escape
 132  * @return {String} safe Unicode escape
 133  */
 134 function _char(c) {
 135     if (!_CHARS[c]) {
 136         _CHARS[c] =  '\\u'+('0000'+(+(c.charCodeAt(0))).toString(16)).slice(-4);
 137     }
 138     return _CHARS[c];
 139 }
 140
 141 /**
 142  * Replace certain Unicode characters that may be handled incorrectly by
 143  * some browser implementations.
 144  * @method _prepare
 145  * @param s {String} parse input
 146  * @return {String} sanitized JSON string ready to be validated/parsed
 147  * @private
 148  */
 149 function _prepare(s) {
 150     return s.replace(_UNICODE_EXCEPTIONS, _char);
 151 }
 152
 153 /**
 154  * Four step determination whether a string is valid JSON.  In three steps,
 155  * escape sequences, safe values, and properly placed open square brackets
 156  * are replaced with placeholders or removed.  Then in the final step, the
 157  * result of all these replacements is checked for invalid characters.
 158  * @method _isValid
 159  * @param str {String} JSON string to be tested
 160  * @return {boolean} is the string safe for eval?
 161  * @static
 162  */
 163 function _isValid(str) {
 164     return l.isString(str) &&
 165             _INVALID.test(str.
 166             replace(_ESCAPES,'@').
 167             replace(_VALUES,']').
 168             replace(_BRACKETS,''));
 169 }
 170
 171 /**
 172  * Enclose escaped strings in quotes
 173  * @method _string
 174  * @param s {String} string to wrap
 175  * @return {String} '"'+s+'"' after s has had special characters escaped
 176  * @private
 177  */
 178 function _string(s) {
 179     return '"' + s.replace(_SPECIAL_CHARS, _char) + '"';
 180 }
 181
 182 /**
 183  * Worker function used by public stringify.
 184  * @method _stringify
 185  * @param h {Object} object holding the key
 186  * @param key {String} String key in object h to serialize
 187  * @param depth {Number} depth to serialize
 188  * @param w {Array|Function} array of whitelisted keys OR replacer function
 189  * @param pstack {Array} used to protect against recursion
 190  * @return {String} serialized version of o
 191  */
 192 function _stringify(h,key,d,w,pstack) {
 193     var o = typeof w === 'function' ? w.call(h,key,h[key]) : h[key],
 194         i,len,j, // array iteration
 195         k,v,     // object iteration
 196         isArray, // forking in typeof 'object'
 197         a;       // composition array for performance over string concat
 198
 199     if (o instanceof Date) {
 200         o = l.JSON.dateToString(o);
 201     } else if (o instanceof String || o instanceof Boolean || o instanceof Number) {
 202         o = o.valueOf();
 203     }
 204
 205     switch (typeof o) {
 206         case 'string' : return _string(o);
 207         case 'number' : return isFinite(o) ? String(o) : 'null';
 208         case 'boolean': return String(o);
 209         case 'object' :
 210             // null
 211             if (o === null) {
 212                 return 'null';
 213             }
 214
 215             // Check for cyclical references
 216             for (i = pstack.length - 1; i >= 0; --i) {
 217                 if (pstack[i] === o) {
 218                     return 'null';
 219                 }
 220             }
 221
 222             // Add the object to the processing stack
 223             pstack[pstack.length] = o;
 224
 225             a = [];
 226             isArray = l.isArray(o);
 227
 228             // Only recurse if we're above depth config
 229             if (d > 0) {
 230                 // Array
 231                 if (isArray) {
 232                     for (i = o.length - 1; i >= 0; --i) {
 233                         a[i] = _stringify(o,i,d-1,w,pstack) || 'null';
 234                     }
 235
 236                 // Object
 237                 } else {
 238                     j = 0;
 239                     // Use whitelist keys if provided as an array
 240                     if (l.isArray(w)) {
 241                         for (i = 0, len = w.length; i < len; ++i) {
 242                             k = w[i];
 243                             v = _stringify(o,k,d-1,w,pstack);
 244                             if (v) {
 245                                 a[j++] = _string(k) + ':' + v;
 246                             }
 247                         }
 248                     } else {
 249                         for (k in o) {
 250                             if (typeof k === 'string' && l.hasOwnProperty(o,k)) {
 251                                 v = _stringify(o,k,d-1,w,pstack);
 252                                 if (v) {
 253                                     a[j++] = _string(k) + ':' + v;
 254                                 }
 255                             }
 256                         }
 257                     }
 258
 259                     // sort object keys for easier readability
 260                     a.sort();
 261                 }
 262             }
 263
 264             // remove the object from the stack
 265             pstack.pop();
 266
 267             return isArray ? '['+a.join(',')+']' : '{'+a.join(',')+'}';
 268     }
 269
 270     return undefined; // invalid input
 271 }
 272
 273 // Return the public API
 274 return {
 275     /**
 276      * Four step determination whether a string is valid JSON.  In three steps,
 277      * escape sequences, safe values, and properly placed open square brackets
 278      * are replaced with placeholders or removed.  Then in the final step, the
 279      * result of all these replacements is checked for invalid characters.
 280      * @method isValid
 281      * @param str {String} JSON string to be tested
 282      * @return {boolean} is the string safe for eval?
 283      * @static
 284      */
 285     isValid : function (s) {
 286         return _isValid(_prepare(s));
 287     },
 288
 289     /**
 290      * Parse a JSON string, returning the native JavaScript representation.
 291      * Only minor modifications from http://www.json.org/json2.js.
 292      * @param s {string} JSON string data
 293      * @param reviver {function} (optional) function(k,v) passed each key:value
 294      *          pair of object literals, allowing pruning or altering values
 295      * @return {MIXED} the native JavaScript representation of the JSON string
 296      * @throws SyntaxError
 297      * @method parse
 298      * @static
 299      */
 300     parse : function (s,reviver) {
 301         // sanitize
 302         s = _prepare(s);
 303
 304         // Ensure valid JSON
 305         if (_isValid(s)) {
 306             // Eval the text into a JavaScript data structure, apply the
 307             // reviver function if provided, and return
 308             return _revive( eval('(' + s + ')'), reviver );
 309         }
 310
 311         // The text is not valid JSON
 312         throw new SyntaxError('parseJSON');
 313     },
 314
 315     /**
 316      * Converts an arbitrary value to a JSON string representation.
 317      * Cyclical object or array references are replaced with null.
 318      * If a whitelist is provided, only matching object keys will be included.
 319      * If a depth limit is provided, objects and arrays at that depth will
 320      * be stringified as empty.
 321      * @method stringify
 322      * @param o {MIXED} any arbitrary object to convert to JSON string
 323      * @param w {Array|Function} (optional) whitelist of acceptable object keys to include OR a function(value,key) to alter values before serialization
 324      * @param d {number} (optional) depth limit to recurse objects/arrays (practical minimum 1)
 325      * @return {string} JSON string representation of the input
 326      * @static
 327      */
 328     stringify : function (o,w,d) {
 329         if (o !== undefined) {
 330             // Ensure whitelist keys are unique (bug 2110391)
 331             if (l.isArray(w)) {
 332                 w = (function (a) {
 333                     var uniq=[],map={},v,i,j,len;
 334                     for (i=0,j=0,len=a.length; i<len; ++i) {
 335                         v = a[i];
 336                         if (typeof v === 'string' && map[v] === undefined) {
 337                             uniq[(map[v] = j++)] = v;
 338                         }
 339                     }
 340                     return uniq;
 341                 })(w);
 342             }
 343
 344             // Default depth to POSITIVE_INFINITY
 345             d = d >= 0 ? d : 1/0;
 346
 347             // process the input
 348             return _stringify({'':o},'',d,w,[]);
 349         }
 350
 351         return undefined;
 352     },
 353
 354     /**
 355      * Serializes a Date instance as a UTC date string.  Used internally by
 356      * stringify.  Override this method if you need Dates serialized in a
 357      * different format.
 358      * @method dateToString
 359      * @param d {Date} The Date to serialize
 360      * @return {String} stringified Date in UTC format YYYY-MM-DDTHH:mm:SSZ
 361      * @static
 362      */
 363     dateToString : function (d) {
 364         function _zeroPad(v) {
 365             return v < 10 ? '0' + v : v;
 366         }
 367
 368         return d.getUTCFullYear()         + '-' +
 369             _zeroPad(d.getUTCMonth() + 1) + '-' +
 370             _zeroPad(d.getUTCDate())      + 'T' +
 371             _zeroPad(d.getUTCHours())     + ':' +
 372             _zeroPad(d.getUTCMinutes())   + ':' +
 373             _zeroPad(d.getUTCSeconds())   + 'Z';
 374     },
 375
 376     /**
 377      * Reconstitute Date instances from the default JSON UTC serialization.
 378      * Reference this from a reviver function to rebuild Dates during the
 379      * parse operation.
 380      * @method stringToDate
 381      * @param str {String} String serialization of a Date
 382      * @return {Date}
 383      */
 384     stringToDate : function (str) {
 385         if (/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.test(str)) {
 386             var d = new Date();
 387             d.setUTCFullYear(RegExp.$1, (RegExp.$2|0)-1, RegExp.$3);
 388             d.setUTCHours(RegExp.$4, RegExp.$5, RegExp.$6);
 389             return d;
 390         }
 391         return str;
 392     }
 393 };
 394
 395 })();
 396 YAHOO.register("json", YAHOO.lang.JSON, {version: "2.7.0", build: "1799"});