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' );