json-stringify.js revision a87b7acef05cfdc407cb96d1f42a0e533a699a80
/**
* Provides Y.JSON.stringify method for converting objects to JSON strings.
*
* @module json
* @submodule json-stringify
* @for JSON
* @static
*/
UNDEFINED = 'undefined',
OBJECT = 'object',
NULL = 'null',
STRING = 'string',
NUMBER = 'number',
BOOLEAN = 'boolean',
DATE = 'date',
_allowable= {
'undefined' : UNDEFINED,
'string' : STRING,
'[object String]' : STRING,
'number' : NUMBER,
'[object Number]' : NUMBER,
'boolean' : BOOLEAN,
'[object Boolean]' : BOOLEAN,
'[object Date]' : DATE,
'[object RegExp]' : OBJECT
},
EMPTY = '',
OPEN_O = '{',
CLOSE_O = '}',
OPEN_A = '[',
CLOSE_A = ']',
COMMA = ',',
COMMA_CR = ",\n",
CR = "\n",
COLON = ':',
COLON_SP = ': ',
QUOTE = '"',
// Regex used to capture characters that need escaping before enclosing
// their containing string in quotes.
_SPECIAL_CHARS = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
// Character substitution map for common escapes and special characters.
_CHARS = {
'\b': '\\b',
'\t': '\\t',
'\n': '\\n',
'\f': '\\f',
'\r': '\\r',
'"' : '\\"',
'\\': '\\\\'
};
// Utility function used to determine how to serialize a variable.
function _type(o) {
var t = typeof o;
return _allowable[t] || // number, string, boolean, undefined
_allowable[_toStr.call(o)] || // Number, String, Boolean, Date
(t === OBJECT ?
(o ? OBJECT : NULL) : // object, array, null, misc natives
UNDEFINED); // function, unknown
}
// Escapes a special character to a safe Unicode representation
function _char(c) {
if (!_CHARS[c]) {
_CHARS[c] = '\\u'+('0000'+(+(c.charCodeAt(0))).toString(16)).slice(-4);
}
return _CHARS[c];
}
// Enclose escaped strings in quotes
function _string(s) {
return QUOTE + s.replace(_SPECIAL_CHARS, _char) + QUOTE;
}
// Adds the provided space to the beginning of every line in the input string
function _indent(s,space) {
return s.replace(/^/gm, space);
}
// JavaScript implementation of stringify (see API declaration of stringify)
function _stringify(o,w,space) {
if (o === undefined) {
return undefined;
}
var replacer = isFunction(w) ? w : null,
format = _toStr.call(space).match(/String|Number/) || [],
_date = Y.JSON.dateToString,
stack = [],
tmp,i,len;
if (replacer || !isArray(w)) {
w = undefined;
}
// Ensure whitelist keys are unique (bug 2110391)
if (w) {
tmp = {};
for (i = 0, len = w.length; i < len; ++i) {
tmp[w[i]] = true;
}
w = tmp;
}
// Per the spec, strings are truncated to 10 characters and numbers
// are converted to that number of spaces (max 10)
space = format[0] === 'Number' ?
new Array(Math.min(Math.max(0,space),10)+1).join(" ") :
(space || EMPTY).slice(0,10);
function _serialize(h,key) {
var value = h[key],
t = _type(value),
a = [],
colon = space ? COLON_SP : COLON,
arr, i, keys, k, v;
// Per the ECMA 5 spec, toJSON is applied before the replacer is
// called. Also per the spec, Date.prototype.toJSON has been added, so
// Date instances should be serialized prior to exposure to the
// replacer. I disagree with this decision, but the spec is the spec.
if (isObject(value) && isFunction(value.toJSON)) {
value = value.toJSON(key);
} else if (t === DATE) {
value = _date(value);
}
if (isFunction(replacer)) {
value = replacer.call(h,key,value);
}
if (value !== h[key]) {
t = _type(value);
}
switch (t) {
case DATE : // intentional fallthrough. Pre-replacer Dates are
// serialized in the toJSON stage. Dates here would
// have been produced by the replacer.
case OBJECT : break;
case STRING : return _string(value);
case NUMBER : return isFinite(value) ? value+EMPTY : NULL;
case BOOLEAN : return value+EMPTY;
case NULL : return NULL;
default : return undefined;
}
// Check for cyclical references in nested objects
for (i = stack.length - 1; i >= 0; --i) {
if (stack[i] === value) {
}
}
arr = isArray(value);
// Add the object to the processing stack
stack.push(value);
if (arr) { // Array
for (i = value.length - 1; i >= 0; --i) {
a[i] = _serialize(value, i) || NULL;
}
} else { // Object
// If whitelist provided, take only those keys
keys = w || value;
i = 0;
for (k in keys) {
if (keys.hasOwnProperty(k)) {
v = _serialize(value, k);
if (v) {
a[i++] = _string(k) + colon + v;
}
}
}
}
// remove the array from the stack
stack.pop();
if (space && a.length) {
return arr ?
OPEN_A + CR + _indent(a.join(COMMA_CR), space) + CR + CLOSE_A :
OPEN_O + CR + _indent(a.join(COMMA_CR), space) + CR + CLOSE_O;
} else {
return arr ?
OPEN_A + a.join(COMMA) + CLOSE_A :
OPEN_O + a.join(COMMA) + CLOSE_O;
}
}
// process the input
return _serialize({'':o},'');
}
Y.mix(Y.namespace('JSON'),{
/**
* Leverage native JSON stringify if the browser has a native
* implementation. In general, this is a good idea. See the Known Issues
* section in the JSON user guide for caveats. The default value is true
* for browsers with native JSON support.
*
* @property JSON.useNativeStringify
* @type Boolean
* @default true
* @static
*/
useNativeStringify : !!Native,
/**
* Serializes a Date instance as a UTC date string. Used internally by
* stringify. Override this method if you need Dates serialized in a
* different format.
*
* @method dateToString
* @param d {Date} The Date to serialize
* @return {String} stringified Date in UTC format YYYY-MM-DDTHH:mm:SSZ
* @static
*/
dateToString : function (d) {
function _zeroPad(v) {
return v < 10 ? '0' + v : v;
}
return d.getUTCFullYear() + '-' +
_zeroPad(d.getUTCMonth() + 1) + '-' +
_zeroPad(d.getUTCDate()) + 'T' +
_zeroPad(d.getUTCHours()) + COLON +
_zeroPad(d.getUTCMinutes()) + COLON +
_zeroPad(d.getUTCSeconds()) + 'Z';
},
/**
* <p>Converts an arbitrary value to a JSON string representation.</p>
*
* <p>Objects with cyclical references will trigger an exception.</p>
*
* <p>If a whitelist is provided, only matching object keys will be
* included. Alternately, a replacer function may be passed as the
* second parameter. This function is executed on every value in the
* input, and its return value will be used in place of the original value.
* This is useful to serialize specialized objects or class instances.</p>
*
* <p>If a positive integer or non-empty string is passed as the third
* parameter, the output will be formatted with carriage returns and
* indentation for readability. If a String is passed (such as "\t") it
* will be used once for each indentation level. If a number is passed,
* that number of spaces will be used.</p>
*
* @method stringify
* @param o {MIXED} any arbitrary value to convert to JSON string
* @param w {Array|Function} (optional) whitelist of acceptable object
* keys to include, or a replacer function to modify the
* raw value before serialization
* @param ind {Number|String} (optional) indentation character or depth of
* spaces to format the output.
* @return {string} JSON string representation of the input
* @static
*/
stringify : function (o,w,ind) {
return Native && Y.JSON.useNativeStringify ?
Native.stringify(o,w,ind) : _stringify(o,w,ind);
}
});
}, '@VERSION@' );