lib/yuilib/3.13.0/json-parse-shim/json-parse-shim.js

   1 /*
   2 YUI 3.13.0 (build 508226d)
   3 Copyright 2013 Yahoo! Inc. All rights reserved.
   4 Licensed under the BSD License.
   5 http://yuilibrary.com/license/
   6 */
   7
   8 YUI.add('json-parse-shim', function (Y, NAME) {
   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  * @main json
  32  * @class JSON
  33  * @static
  34  */
  35
  36 /**
  37  * Provides Y.JSON.parse method to accept JSON strings and return native
  38  * JavaScript objects.
  39  *
  40  * @module json
  41  * @submodule json-parse
  42  * @for JSON
  43  * @static
  44  */
  45
  46
  47     /**
  48      * Replace certain Unicode characters that JavaScript may handle incorrectly
  49      * during eval--either by deleting them or treating them as line
  50      * endings--with escape sequences.
  51      * IMPORTANT NOTE: This regex will be used to modify the input if a match is
  52      * found.
  53      *
  54      * @property _UNICODE_EXCEPTIONS
  55      * @type {RegExp}
  56      * @private
  57      */
  58 var _UNICODE_EXCEPTIONS = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
  59
  60
  61     /**
  62      * First step in the safety evaluation.  Regex used to replace all escape
  63      * sequences (i.e. "\\", etc) with '@' characters (a non-JSON character).
  64      *
  65      * @property _ESCAPES
  66      * @type {RegExp}
  67      * @private
  68      */
  69     _ESCAPES = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
  70
  71     /**
  72      * Second step in the safety evaluation.  Regex used to replace all simple
  73      * values with ']' characters.
  74      *
  75      * @property _VALUES
  76      * @type {RegExp}
  77      * @private
  78      */
  79     _VALUES  = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
  80
  81     /**
  82      * Third step in the safety evaluation.  Regex used to remove all open
  83      * square brackets following a colon, comma, or at the beginning of the
  84      * string.
  85      *
  86      * @property _BRACKETS
  87      * @type {RegExp}
  88      * @private
  89      */
  90     _BRACKETS = /(?:^|:|,)(?:\s*\[)+/g,
  91
  92     /**
  93      * Final step in the safety evaluation.  Regex used to test the string left
  94      * after all previous replacements for invalid characters.
  95      *
  96      * @property _UNSAFE
  97      * @type {RegExp}
  98      * @private
  99      */
 100     _UNSAFE = /[^\],:{}\s]/,
 101
 102     /**
 103      * Replaces specific unicode characters with their appropriate \unnnn
 104      * format. Some browsers ignore certain characters during eval.
 105      *
 106      * @method escapeException
 107      * @param c {String} Unicode character
 108      * @return {String} the \unnnn escapement of the character
 109      * @private
 110      */
 111     _escapeException = function (c) {
 112         return '\\u'+('0000'+(+(c.charCodeAt(0))).toString(16)).slice(-4);
 113     },
 114
 115     /**
 116      * Traverses nested objects, applying a reviver function to each (key,value)
 117      * from the scope if the key:value's containing object.  The value returned
 118      * from the function will replace the original value in the key:value pair.
 119      * If the value returned is undefined, the key will be omitted from the
 120      * returned object.
 121      *
 122      * @method _revive
 123      * @param data {MIXED} Any JavaScript data
 124      * @param reviver {Function} filter or mutation function
 125      * @return {MIXED} The results of the filtered data
 126      * @private
 127      */
 128     _revive = function (data, reviver) {
 129         var walk = function (o,key) {
 130             var k,v,value = o[key];
 131             if (value && typeof value === 'object') {
 132                 for (k in value) {
 133                     if (value.hasOwnProperty(k)) {
 134                         v = walk(value, k);
 135                         if (v === undefined) {
 136                             delete value[k];
 137                         } else {
 138                             value[k] = v;
 139                         }
 140                     }
 141                 }
 142             }
 143             return reviver.call(o,key,value);
 144         };
 145
 146         return typeof reviver === 'function' ? walk({'':data},'') : data;
 147     };
 148
 149 /**
 150  * Parse a JSON string, returning the native JavaScript representation.
 151  *
 152  * @param s {string} JSON string data
 153  * @param reviver {function} (optional) function(k,v) passed each key value
 154  *          pair of object literals, allowing pruning or altering values
 155  * @return {MIXED} the native JavaScript representation of the JSON string
 156  * @throws SyntaxError
 157  * @method parse
 158  * @static
 159  */
 160 // JavaScript implementation in lieu of native browser support.  Based on
 161 // the json2.js library from http://json.org
 162 Y.JSON.parse = function (s,reviver) {
 163     if (typeof s !== 'string') {
 164         s += '';
 165     }
 166
 167     // Replace certain Unicode characters that are otherwise handled
 168     // incorrectly by some browser implementations.
 169     // NOTE: This modifies the input if such characters are found!
 170     s = s.replace(_UNICODE_EXCEPTIONS, _escapeException);
 171
 172     // Test for any remaining invalid characters
 173     if (!_UNSAFE.test(s.replace(_ESCAPES,'@').
 174                         replace(_VALUES,']').
 175                         replace(_BRACKETS,''))) {
 176
 177         // Eval the text into a JavaScript data structure, apply any
 178         // reviver function, and return
 179         return _revive(eval('(' + s + ')'), reviver);
 180     }
 181
 182     throw new SyntaxError('JSON.parse');
 183 };
 184
 185 // Property available for testing if the implementation being used
 186 // is native or a shim
 187 Y.JSON.parse.isShim = true;
 188
 189
 190 }, '3.13.0', {"requires": ["json-parse"]});