[Summary view] [Print] [Text view]

   1  /*
   2  YUI 3.17.2 (build 9c3c78e)
   3  Copyright 2014 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.17.2', {"requires": ["json-parse"]});