lib/yuilib/3.13.0/json-stringify-shim/json-stringify-shim-debug.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-stringify-shim', function (Y, NAME) {
   9
  10 // All internals kept private for security reasons
  11 var Lang      = Y.Lang,
  12     isFunction= Lang.isFunction,
  13     isObject  = Lang.isObject,
  14     isArray   = Lang.isArray,
  15     _toStr    = Object.prototype.toString,
  16     UNDEFINED = 'undefined',
  17     OBJECT    = 'object',
  18     NULL      = 'null',
  19     STRING    = 'string',
  20     NUMBER    = 'number',
  21     BOOLEAN   = 'boolean',
  22     DATE      = 'date',
  23     _allowable= {
  24         'undefined'        : UNDEFINED,
  25         'string'           : STRING,
  26         '[object String]'  : STRING,
  27         'number'           : NUMBER,
  28         '[object Number]'  : NUMBER,
  29         'boolean'          : BOOLEAN,
  30         '[object Boolean]' : BOOLEAN,
  31         '[object Date]'    : DATE,
  32         '[object RegExp]'  : OBJECT
  33     },
  34     EMPTY     = '',
  35     OPEN_O    = '{',
  36     CLOSE_O   = '}',
  37     OPEN_A    = '[',
  38     CLOSE_A   = ']',
  39     COMMA     = ',',
  40     COMMA_CR  = ",\n",
  41     CR        = "\n",
  42     COLON     = ':',
  43     COLON_SP  = ': ',
  44     QUOTE     = '"',
  45
  46     // Regex used to capture characters that need escaping before enclosing
  47     // their containing string in quotes.
  48     _SPECIAL = /[\x00-\x07\x0b\x0e-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
  49
  50     // Character substitution map for common escapes and special characters.
  51     _COMMON = [
  52         [/\\/g, '\\\\'],
  53         [/\"/g, '\\"'],
  54         [/\x08/g, '\\b'],
  55         [/\x09/g, '\\t'],
  56         [/\x0a/g, '\\n'],
  57         [/\x0c/g, '\\f'],
  58         [/\x0d/g, '\\r']
  59     ],
  60     _COMMON_LENGTH = _COMMON.length,
  61
  62     // In-process optimization for special character escapes that haven't yet
  63     // been promoted to _COMMON
  64     _CHAR = {},
  65
  66     // Per-char counter to determine if it's worth fast tracking a special
  67     // character escape sequence.
  68     _CHAR_COUNT, _CACHE_THRESHOLD;
  69
  70 // Utility function used to determine how to serialize a variable.
  71 function _type(o) {
  72     var t = typeof o;
  73     return  _allowable[t] ||              // number, string, boolean, undefined
  74             _allowable[_toStr.call(o)] || // Number, String, Boolean, Date
  75             (t === OBJECT ?
  76                 (o ? OBJECT : NULL) :     // object, array, null, misc natives
  77                 UNDEFINED);               // function, unknown
  78 }
  79
  80 // Escapes a special character to a safe Unicode representation
  81 function _char(c) {
  82     if (!_CHAR[c]) {
  83         _CHAR[c] = '\\u'+('0000'+(+(c.charCodeAt(0))).toString(16)).slice(-4);
  84         _CHAR_COUNT[c] = 0;
  85     }
  86
  87     // === to avoid this conditional for the remainder of the current operation
  88     if (++_CHAR_COUNT[c] === _CACHE_THRESHOLD) {
  89         _COMMON.push([new RegExp(c, 'g'), _CHAR[c]]);
  90         _COMMON_LENGTH = _COMMON.length;
  91     }
  92
  93     return _CHAR[c];
  94 }
  95
  96 // Enclose escaped strings in quotes
  97 function _string(s) {
  98     var i, chr;
  99
 100     // Preprocess the string against common characters to avoid function
 101     // overhead associated with replacement via function.
 102     for (i = 0; i < _COMMON_LENGTH; i++) {
 103         chr = _COMMON[i];
 104         s = s.replace(chr[0], chr[1]);
 105     }
 106
 107     // original function replace for the not-as-common set of chars
 108     return QUOTE + s.replace(_SPECIAL, _char) + QUOTE;
 109 }
 110
 111 // Adds the provided space to the beginning of every line in the input string
 112 function _indent(s,space) {
 113     return s.replace(/^/gm, space);
 114 }
 115
 116 Y.JSON.stringify = function _stringify(o,w,space) {
 117     if (o === undefined) {
 118         return undefined;
 119     }
 120
 121     var replacer = isFunction(w) ? w : null,
 122         format   = _toStr.call(space).match(/String|Number/) || [],
 123         _date    = Y.JSON.dateToString,
 124         stack    = [],
 125         tmp,i,len;
 126
 127     _CHAR_COUNT      = {};
 128     _CACHE_THRESHOLD = Y.JSON.charCacheThreshold;
 129
 130     if (replacer || !isArray(w)) {
 131         w = undefined;
 132     }
 133
 134     // Ensure whitelist keys are unique (bug 2110391)
 135     if (w) {
 136         tmp = {};
 137         for (i = 0, len = w.length; i < len; ++i) {
 138             tmp[w[i]] = true;
 139         }
 140         w = tmp;
 141     }
 142
 143     // Per the spec, strings are truncated to 10 characters and numbers
 144     // are converted to that number of spaces (max 10)
 145     space = format[0] === 'Number' ?
 146                 new Array(Math.min(Math.max(0,space),10)+1).join(" ") :
 147                 (space || EMPTY).slice(0,10);
 148
 149     function _serialize(h,key) {
 150         var value = h[key],
 151             t     = _type(value),
 152             a     = [],
 153             colon = space ? COLON_SP : COLON,
 154             arr, i, keys, k, v;
 155
 156         // Per the ECMA 5 spec, toJSON is applied before the replacer is
 157         // called.  Also per the spec, Date.prototype.toJSON has been added, so
 158         // Date instances should be serialized prior to exposure to the
 159         // replacer.  I disagree with this decision, but the spec is the spec.
 160         if (isObject(value) && isFunction(value.toJSON)) {
 161             value = value.toJSON(key);
 162         } else if (t === DATE) {
 163             value = _date(value);
 164         }
 165
 166         if (isFunction(replacer)) {
 167             value = replacer.call(h,key,value);
 168         }
 169
 170         if (value !== h[key]) {
 171             t = _type(value);
 172         }
 173
 174         switch (t) {
 175             case DATE    : // intentional fallthrough.  Pre-replacer Dates are
 176                            // serialized in the toJSON stage.  Dates here would
 177                            // have been produced by the replacer.
 178             case OBJECT  : break;
 179             case STRING  : return _string(value);
 180             case NUMBER  : return isFinite(value) ? value+EMPTY : NULL;
 181             case BOOLEAN : return value+EMPTY;
 182             case NULL    : return NULL;
 183             default      : return undefined;
 184         }
 185
 186         // Check for cyclical references in nested objects
 187         for (i = stack.length - 1; i >= 0; --i) {
 188             if (stack[i] === value) {
 189                 throw new Error("JSON.stringify. Cyclical reference");
 190             }
 191         }
 192
 193         arr = isArray(value);
 194
 195         // Add the object to the processing stack
 196         stack.push(value);
 197
 198         if (arr) { // Array
 199             for (i = value.length - 1; i >= 0; --i) {
 200                 a[i] = _serialize(value, i) || NULL;
 201             }
 202         } else {   // Object
 203             // If whitelist provided, take only those keys
 204             keys = w || value;
 205             i = 0;
 206
 207             for (k in keys) {
 208                 if (keys.hasOwnProperty(k)) {
 209                     v = _serialize(value, k);
 210                     if (v) {
 211                         a[i++] = _string(k) + colon + v;
 212                     }
 213                 }
 214             }
 215         }
 216
 217         // remove the array from the stack
 218         stack.pop();
 219
 220         if (space && a.length) {
 221             return arr ?
 222                 OPEN_A + CR + _indent(a.join(COMMA_CR), space) + CR + CLOSE_A :
 223                 OPEN_O + CR + _indent(a.join(COMMA_CR), space) + CR + CLOSE_O;
 224         } else {
 225             return arr ?
 226                 OPEN_A + a.join(COMMA) + CLOSE_A :
 227                 OPEN_O + a.join(COMMA) + CLOSE_O;
 228         }
 229     }
 230
 231     // process the input
 232     return _serialize({'':o},'');
 233 };
 234
 235 // Property available for testing if the implementation being used
 236 // is native or a shim
 237 Y.JSON.stringify.isShim = true;
 238
 239
 240 }, '3.13.0', {"requires": ["json-stringify"]});