--- /dev/null
+/*
+ * Author: Alex Kocharin <alex@kocharin.ru>
+ * GIT: https://github.com/rlidwka/jju
+ * License: WTFPL, grab your copy here: http://www.wtfpl.net/txt/copying/
+ */
+
+var Uni = require('./unicode')
+
+// Fix Function#name on browsers that do not support it (IE)
+// http://stackoverflow.com/questions/6903762/function-name-not-supported-in-ie
+if (!(function f(){}).name) {
+ Object.defineProperty((function(){}).constructor.prototype, 'name', {
+ get: function() {
+ var name = this.toString().match(/^\s*function\s*(\S*)\s*\(/)[1]
+ // For better performance only parse once, and then cache the
+ // result through a new accessor for repeated access.
+ Object.defineProperty(this, 'name', { value: name })
+ return name
+ }
+ })
+}
+
+var special_chars = {
+ 0: '\\0', // this is not an octal literal
+ 8: '\\b',
+ 9: '\\t',
+ 10: '\\n',
+ 11: '\\v',
+ 12: '\\f',
+ 13: '\\r',
+ 92: '\\\\',
+}
+
+// for oddballs
+var hasOwnProperty = Object.prototype.hasOwnProperty
+
+// some people escape those, so I'd copy this to be safe
+var escapable = /[\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/
+
+function _stringify(object, options, recursiveLvl, currentKey) {
+ var json5 = (options.mode === 'json5' || !options.mode)
+ /*
+ * Opinionated decision warning:
+ *
+ * Objects are serialized in the following form:
+ * { type: 'Class', data: DATA }
+ *
+ * Class is supposed to be a function, and new Class(DATA) is
+ * supposed to be equivalent to the original value
+ */
+ /*function custom_type() {
+ return stringify({
+ type: object.constructor.name,
+ data: object.toString()
+ })
+ }*/
+
+ // if add, it's an internal indentation, so we add 1 level and a eol
+ // if !add, it's an ending indentation, so we just indent
+ function indent(str, add) {
+ var prefix = options._prefix ? options._prefix : ''
+ if (!options.indent) return prefix + str
+ var result = ''
+ var count = recursiveLvl + (add || 0)
+ for (var i=0; i<count; i++) result += options.indent
+ return prefix + result + str + (add ? '\n' : '')
+ }
+
+ function _stringify_key(key) {
+ if (options.quote_keys) return _stringify_str(key)
+ if (String(Number(key)) == key && key[0] != '-') return key
+ if (key == '') return _stringify_str(key)
+
+ var result = ''
+ for (var i=0; i<key.length; i++) {
+ if (i > 0) {
+ if (!Uni.isIdentifierPart(key[i]))
+ return _stringify_str(key)
+
+ } else {
+ if (!Uni.isIdentifierStart(key[i]))
+ return _stringify_str(key)
+ }
+
+ var chr = key.charCodeAt(i)
+
+ if (options.ascii) {
+ if (chr < 0x80) {
+ result += key[i]
+
+ } else {
+ result += '\\u' + ('0000' + chr.toString(16)).slice(-4)
+ }
+
+ } else {
+ if (escapable.exec(key[i])) {
+ result += '\\u' + ('0000' + chr.toString(16)).slice(-4)
+
+ } else {
+ result += key[i]
+ }
+ }
+ }
+
+ return result
+ }
+
+ function _stringify_str(key) {
+ var quote = options.quote
+ var quoteChr = quote.charCodeAt(0)
+
+ var result = ''
+ for (var i=0; i<key.length; i++) {
+ var chr = key.charCodeAt(i)
+
+ if (chr < 0x10) {
+ if (chr === 0 && json5) {
+ result += '\\0'
+ } else if (chr >= 8 && chr <= 13 && (json5 || chr !== 11)) {
+ result += special_chars[chr]
+ } else if (json5) {
+ result += '\\x0' + chr.toString(16)
+ } else {
+ result += '\\u000' + chr.toString(16)
+ }
+
+ } else if (chr < 0x20) {
+ if (json5) {
+ result += '\\x' + chr.toString(16)
+ } else {
+ result += '\\u00' + chr.toString(16)
+ }
+
+ } else if (chr >= 0x20 && chr < 0x80) {
+ // ascii range
+ if (chr === 47 && i && key[i-1] === '<') {
+ // escaping slashes in </script>
+ result += '\\' + key[i]
+
+ } else if (chr === 92) {
+ result += '\\\\'
+
+ } else if (chr === quoteChr) {
+ result += '\\' + quote
+
+ } else {
+ result += key[i]
+ }
+
+ } else if (options.ascii || Uni.isLineTerminator(key[i]) || escapable.exec(key[i])) {
+ if (chr < 0x100) {
+ if (json5) {
+ result += '\\x' + chr.toString(16)
+ } else {
+ result += '\\u00' + chr.toString(16)
+ }
+
+ } else if (chr < 0x1000) {
+ result += '\\u0' + chr.toString(16)
+
+ } else if (chr < 0x10000) {
+ result += '\\u' + chr.toString(16)
+
+ } else {
+ throw Error('weird codepoint')
+ }
+ } else {
+ result += key[i]
+ }
+ }
+ return quote + result + quote
+ }
+
+ function _stringify_object() {
+ if (object === null) return 'null'
+ var result = []
+ , len = 0
+ , braces
+
+ if (Array.isArray(object)) {
+ braces = '[]'
+ for (var i=0; i<object.length; i++) {
+ var s = _stringify(object[i], options, recursiveLvl+1, String(i))
+ if (s === undefined) s = 'null'
+ len += s.length + 2
+ result.push(s + ',')
+ }
+
+ } else {
+ braces = '{}'
+ var fn = function(key) {
+ var t = _stringify(object[key], options, recursiveLvl+1, key)
+ if (t !== undefined) {
+ t = _stringify_key(key) + ':' + (options.indent ? ' ' : '') + t + ','
+ len += t.length + 1
+ result.push(t)
+ }
+ }
+
+ if (Array.isArray(options.replacer)) {
+ for (var i=0; i<options.replacer.length; i++)
+ if (hasOwnProperty.call(object, options.replacer[i]))
+ fn(options.replacer[i])
+ } else {
+ var keys = Object.keys(object)
+ if (options.sort_keys)
+ keys = keys.sort(typeof(options.sort_keys) === 'function'
+ ? options.sort_keys : undefined)
+ keys.forEach(fn)
+ }
+ }
+
+ // objects shorter than 30 characters are always inlined
+ // objects longer than 60 characters are always splitted to multiple lines
+ // anything in the middle depends on indentation level
+ len -= 2
+ if (options.indent && (len > options._splitMax - recursiveLvl * options.indent.length || len > options._splitMin) ) {
+ // remove trailing comma in multiline if asked to
+ if (options.no_trailing_comma && result.length) {
+ result[result.length-1] = result[result.length-1].substring(0, result[result.length-1].length-1)
+ }
+
+ var innerStuff = result.map(function(x) {return indent(x, 1)}).join('')
+ return braces[0]
+ + (options.indent ? '\n' : '')
+ + innerStuff
+ + indent(braces[1])
+ } else {
+ // always remove trailing comma in one-lined arrays
+ if (result.length) {
+ result[result.length-1] = result[result.length-1].substring(0, result[result.length-1].length-1)
+ }
+
+ var innerStuff = result.join(options.indent ? ' ' : '')
+ return braces[0]
+ + innerStuff
+ + braces[1]
+ }
+ }
+
+ function _stringify_nonobject(object) {
+ if (typeof(options.replacer) === 'function') {
+ object = options.replacer.call(null, currentKey, object)
+ }
+
+ switch(typeof(object)) {
+ case 'string':
+ return _stringify_str(object)
+
+ case 'number':
+ if (object === 0 && 1/object < 0) {
+ // Opinionated decision warning:
+ //
+ // I want cross-platform negative zero in all js engines
+ // I know they're equal, but why lose that tiny bit of
+ // information needlessly?
+ return '-0'
+ }
+ if (!json5 && !Number.isFinite(object)) {
+ // json don't support infinity (= sucks)
+ return 'null'
+ }
+ return object.toString()
+
+ case 'boolean':
+ return object.toString()
+
+ case 'undefined':
+ return undefined
+
+ case 'function':
+// return custom_type()
+
+ default:
+ // fallback for something weird
+ return JSON.stringify(object)
+ }
+ }
+
+ if (options._stringify_key) {
+ return _stringify_key(object)
+ }
+
+ if (typeof(object) === 'object') {
+ if (object === null) return 'null'
+
+ var str
+ if (typeof(str = object.toJSON5) === 'function' && options.mode !== 'json') {
+ object = str.call(object, currentKey)
+
+ } else if (typeof(str = object.toJSON) === 'function') {
+ object = str.call(object, currentKey)
+ }
+
+ if (object === null) return 'null'
+ if (typeof(object) !== 'object') return _stringify_nonobject(object)
+
+ if (object.constructor === Number || object.constructor === Boolean || object.constructor === String) {
+ object = object.valueOf()
+ return _stringify_nonobject(object)
+
+ } else if (object.constructor === Date) {
+ // only until we can't do better
+ return _stringify_nonobject(object.toISOString())
+
+ } else {
+ if (typeof(options.replacer) === 'function') {
+ object = options.replacer.call(null, currentKey, object)
+ if (typeof(object) !== 'object') return _stringify_nonobject(object)
+ }
+
+ return _stringify_object(object)
+ }
+ } else {
+ return _stringify_nonobject(object)
+ }
+}
+
+/*
+ * stringify(value, options)
+ * or
+ * stringify(value, replacer, space)
+ *
+ * where:
+ * value - anything
+ * options - object
+ * replacer - function or array
+ * space - boolean or number or string
+ */
+module.exports.stringify = function stringifyJSON(object, options, _space) {
+ // support legacy syntax
+ if (typeof(options) === 'function' || Array.isArray(options)) {
+ options = {
+ replacer: options
+ }
+ } else if (typeof(options) === 'object' && options !== null) {
+ // nothing to do
+ } else {
+ options = {}
+ }
+ if (_space != null) options.indent = _space
+
+ if (options.indent == null) options.indent = '\t'
+ if (options.quote == null) options.quote = "'"
+ if (options.ascii == null) options.ascii = false
+ if (options.mode == null) options.mode = 'json5'
+
+ if (options.mode === 'json' || options.mode === 'cjson') {
+ // json only supports double quotes (= sucks)
+ options.quote = '"'
+
+ // json don't support trailing commas (= sucks)
+ options.no_trailing_comma = true
+
+ // json don't support unquoted property names (= sucks)
+ options.quote_keys = true
+ }
+
+ // why would anyone use such objects?
+ if (typeof(options.indent) === 'object') {
+ if (options.indent.constructor === Number
+ || options.indent.constructor === Boolean
+ || options.indent.constructor === String)
+ options.indent = options.indent.valueOf()
+ }
+
+ // gap is capped at 10 characters
+ if (typeof(options.indent) === 'number') {
+ if (options.indent >= 0) {
+ options.indent = Array(Math.min(~~options.indent, 10) + 1).join(' ')
+ } else {
+ options.indent = false
+ }
+ } else if (typeof(options.indent) === 'string') {
+ options.indent = options.indent.substr(0, 10)
+ }
+
+ if (options._splitMin == null) options._splitMin = 50
+ if (options._splitMax == null) options._splitMax = 70
+
+ return _stringify(object, options, 0, '')
+}
+
Code Review / simantics / district.git / blobdiff