jssource/src_files/include/javascript/yui3/build/json/json-parse.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: 3.0.0
   6 build: 1549
   7 */
   8 YUI.add('json-parse', function(Y) {
   9
  10 /**
  11  * <p>The JSON module adds support for serializing JavaScript objects into
  12  * JSON strings and parsing JavaScript objects from strings in JSON format.</p>
  13  *
  14  * <p>The JSON namespace is added to your YUI instance including static methods
  15  * Y.JSON.parse(..) and Y.JSON.stringify(..).</p>
  16  *
  17  * <p>The functionality and method signatures follow the ECMAScript 5
  18  * specification.  In browsers with native JSON support, the native
  19  * implementation is used.</p>
  20  *
  21  * <p>The <code>json</code> module is a rollup of <code>json-parse</code> and
  22  * <code>json-stringify</code>.</p>
  23  *
  24  * <p>As their names suggest, <code>json-parse</code> adds support for parsing
  25  * JSON data (Y.JSON.parse) and <code>json-stringify</code> for serializing
  26  * JavaScript data into JSON strings (Y.JSON.stringify).  You may choose to
  27  * include either of the submodules individually if you don't need the
  28  * complementary functionality, or include the rollup for both.</p>
  29  *
  30  * @module json
  31  * @class JSON
  32  * @static
  33  */
  34
  35 /**
  36  * Provides Y.JSON.parse method to accept JSON strings and return native
  37  * JavaScript objects.
  38  *
  39  * @module json
  40  * @submodule json-parse
  41  * @for JSON
  42  * @static
  43  */
  44
  45
  46 // All internals kept private for security reasons
  47
  48
  49     /**
  50      * Alias to native browser implementation of the JSON object if available.
  51      *
  52      * @property Native
  53      * @type {Object}
  54      * @private
  55      */
  56 var _JSON  = Y.config.win.JSON,
  57     Native = (Object.prototype.toString.call(_JSON) === '[object JSON]' && _JSON),
  58
  59     /**
  60      * Replace certain Unicode characters that JavaScript may handle incorrectly
  61      * during eval--either by deleting them or treating them as line
  62      * endings--with escape sequences.
  63      * IMPORTANT NOTE: This regex will be used to modify the input if a match is
  64      * found.
  65      *
  66      * @property _UNICODE_EXCEPTIONS
  67      * @type {RegExp}
  68      * @private
  69      */
  70     _UNICODE_EXCEPTIONS = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
  71
  72
  73     /**
  74      * First step in the safety evaluation.  Regex used to replace all escape
  75      * sequences (i.e. "\\", etc) with '@' characters (a non-JSON character).
  76      *
  77      * @property _ESCAPES
  78      * @type {RegExp}
  79      * @private
  80      */
  81     _ESCAPES = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
  82
  83     /**
  84      * Second step in the safety evaluation.  Regex used to replace all simple
  85      * values with ']' characters.
  86      *
  87      * @property _VALUES
  88      * @type {RegExp}
  89      * @private
  90      */
  91     _VALUES  = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
  92
  93     /**
  94      * Third step in the safety evaluation.  Regex used to remove all open
  95      * square brackets following a colon, comma, or at the beginning of the
  96      * string.
  97      *
  98      * @property _BRACKETS
  99      * @type {RegExp}
 100      * @private
 101      */
 102     _BRACKETS = /(?:^|:|,)(?:\s*\[)+/g,
 103
 104     /**
 105      * Final step in the safety evaluation.  Regex used to test the string left
 106      * after all previous replacements for invalid characters.
 107      *
 108      * @property _UNSAFE
 109      * @type {RegExp}
 110      * @private
 111      */
 112     _UNSAFE = /[^\],:{}\s]/,
 113
 114     /**
 115      * Replaces specific unicode characters with their appropriate \unnnn
 116      * format. Some browsers ignore certain characters during eval.
 117      *
 118      * @method escapeException
 119      * @param c {String} Unicode character
 120      * @return {String} the \unnnn escapement of the character
 121      * @private
 122      */
 123     _escapeException = function (c) {
 124         return '\\u'+('0000'+(+(c.charCodeAt(0))).toString(16)).slice(-4);
 125     },
 126
 127     /**
 128      * Traverses nested objects, applying a reviver function to each (key,value)
 129      * from the scope if the key:value's containing object.  The value returned
 130      * from the function will replace the original value in the key:value pair.
 131      * If the value returned is undefined, the key will be omitted from the
 132      * returned object.
 133      *
 134      * @method _revive
 135      * @param data {MIXED} Any JavaScript data
 136      * @param reviver {Function} filter or mutation function
 137      * @return {MIXED} The results of the filtered data
 138      * @private
 139      */
 140     _revive = function (data, reviver) {
 141         var walk = function (o,key) {
 142             var k,v,value = o[key];
 143             if (value && typeof value === 'object') {
 144                 for (k in value) {
 145                     if (value.hasOwnProperty(k)) {
 146                         v = walk(value, k);
 147                         if (v === undefined) {
 148                             delete value[k];
 149                         } else {
 150                             value[k] = v;
 151                         }
 152                     }
 153                 }
 154             }
 155             return reviver.call(o,key,value);
 156         };
 157
 158         return typeof reviver === 'function' ? walk({'':data},'') : data;
 159     },
 160
 161     /**
 162      * Parse a JSON string, returning the native JavaScript representation.
 163      *
 164      * @param s {string} JSON string data
 165      * @param reviver {function} (optional) function(k,v) passed each key value
 166      *          pair of object literals, allowing pruning or altering values
 167      * @return {MIXED} the native JavaScript representation of the JSON string
 168      * @throws SyntaxError
 169      * @method parse
 170      * @static
 171      */
 172     // JavaScript implementation in lieu of native browser support.  Based on
 173     // the json2.js library from http://json.org
 174     _parse = function (s,reviver) {
 175         if (typeof s === 'string') {
 176             // Replace certain Unicode characters that are otherwise handled
 177             // incorrectly by some browser implementations.
 178             // NOTE: This modifies the input if such characters are found!
 179             s = s.replace(_UNICODE_EXCEPTIONS, _escapeException);
 180
 181             // Test for any remaining invalid characters
 182             if (!_UNSAFE.test(s.replace(_ESCAPES,'@').
 183                                  replace(_VALUES,']').
 184                                  replace(_BRACKETS,''))) {
 185
 186                 // Eval the text into a JavaScript data structure, apply any
 187                 // reviver function, and return
 188                 return _revive( eval('(' + s + ')'), reviver );
 189             }
 190         }
 191
 192         throw new SyntaxError('JSON.parse');
 193     };
 194
 195 Y.namespace('JSON').parse = function (s,reviver) {
 196     return Native && Y.JSON.useNativeParse ?
 197         Native.parse(s,reviver) : _parse(s,reviver);
 198 };
 199
 200 /**
 201  * Leverage native JSON parse if the browser has a native implementation.
 202  * In general, this is a good idea.  See the Known Issues section in the
 203  * JSON user guide for caveats.  The default value is true for browsers with
 204  * native JSON support.
 205  *
 206  * @property useNativeParse
 207  * @type Boolean
 208  * @default true
 209  * @static
 210  */
 211 Y.JSON.useNativeParse = !!Native;
 212
 213
 214 }, '3.0.0' );