ig-serialize 1.0.4 → 1.0.6

package/README.md

@@ -49,6 +49,33 @@ Thus, care must be taken when serializing structures containing function.
 ### `partialDeepCopy(..)`
 
 
+## Format
+
+The output of `.serialize(..)` is a strict superset of [standard JSON](https://www.json.org/json-en.html), 
+while the input format is a bit more relaxed than in several details.
+
+Extensions to JSON:
+- Recursion
+- undefined / NaN
+- BigInt
+- Map / Set
+- Function
+
+### Structural paths
+
+### Recursion
+
+### null types
+
+### BigInt
+
+### Map / Set
+
+### Functions
+
+
+
+
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ig-serialize",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "experimental extended json serializaion...",
   "main": "serialize.js",
   "scripts": {

package/serialize.js

@@ -1,5 +1,41 @@
 /**********************************************************************
 * 
+* TODO would be useful to split this into:
+* 	- object traversal using object path
+* 		Object.walk(..) -- a-la Python's walk(..)
+* 		Object.graph(..)
+* 			like .map(..) but deep and paths instead of indexes...
+* 	- get/set object by path
+* 		Object.get(..) / Object.set(..)
+*
+* XXX the current path implementation is fully complient to the task at 
+* 	hand but it will not suite the diff task as there is no way to know
+* 	the meaning of the path element without seeing the object (map/set 
+* 	indexes)...
+* 	a different path format would suit both tasks and make things more 
+* 	universal:
+* 		Current:
+*	 		[1, 'a', 5, 0, 3]
+*	 		 \   \   +-++  +---------------- Set index (from context)
+*	 		  \   \     +------------------- Map index (from context)
+*	 		   \   +------------------------ Object key (string)
+*	 		    +--------------------------- Array index (from context)
+* 		Proposed:
+*	 		[1, 'a', ['map', 5, 0], ['set', 3]]
+*	 		 \   \   +---------+-+  +------+-+
+*	 		  \   \             \           +--- Set index
+*			   \   \             +-------------- Map index
+*				\   +--------------------------- Object key (string)
+*				 +------------------------------ Array index (number)
+*		And/or:
+*	 		[1, ['object', 3], ['map', 5, 0], ['set', 3]]
+*	 		    +---------+-+
+*	 		               +----- Object attr index
+*	The questions is which to use as default for objects, the key or 
+*	position?
+*	(XXX move this note to diff.jx)
+*
+* XXX do a revision of the JSON standard for things I could have forgotten...
 *
 *
 **********************************************************************/
@@ -41,7 +77,8 @@ var debug = {
 
 //---------------------------------------------------------------------
 
-module.STRING_LENGTH_REF = 64
+module.STRING_LENGTH_REF = RECURSIVE.length * 8
+
 
 //
 // 	serialize(obj[, options])
@@ -101,7 +138,7 @@ module.STRING_LENGTH_REF = 64
 // 		]
 //
 //
-// XXX BUG: using non-whitespace as indent breaks the depth of the first 
+// XXX BUG?: using non-whitespace as indent breaks the depth of the first 
 // 		or last elements in sequences
 // 		...breaks .trim*() in Map/Set/Object...
 var _serialize = 
@@ -131,7 +168,8 @@ function(obj, path=[], seen=new Map(), indent, depth=0, options={}){
 		return FUNCTION
 			.replace('%', s.length +','+ s) }
 
-	// special case: long strings...
+	// long strings...
+	// NOTE: this saves on output size...
 	if(typeof(obj) == 'string' 
 			&& obj.length > string_length_ref){
 		seen.set(obj, path) }
@@ -230,7 +268,7 @@ module.eJSON = {
 
 		0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number',
 		5: 'number', 6: 'number', 7: 'number', 8: 'number', 9: 'number',
-		'.': 'number', '-': 'number',
+		'.': 'number', '-': 'number', '+': 'number',
 
 		'[': 'array',
 		'{': 'object',
@@ -370,11 +408,34 @@ module.eJSON = {
 				&& str.slice(i, i+'-Infinity'.length) == '-Infinity'){
 			return [-Infinity, i+'-Infinity'.length, line] }
 		// numbers...
-		var j = i+1
+		// XXX do we need to handle the odd case of 077 vs 088???
+		var j = i
+		var mode = 'dec'
+		if(str[j] == '0' 
+				&& 'xXbBoO'.includes(str[j+1])){
+			mode = str[j+1].toLowerCase()
+			j++ }
+		j++
 		while(j < str.length
 				&& (str[j] == '.'
+					// dec/oct/bin...
+					// XXX do we need to be pedantic and check the rest 
+					// 		of the modes explicitly???
 					|| (str[j] >= '0'
-						&& str[j] <= '9'))){
+						&& str[j] <= '9')
+					// hex...
+					|| (mode == 'x'
+						&& ((str[j] >= 'a'
+								&& str[j] <= 'f')
+							|| (str[j] >= 'A'
+								&& str[j] <= 'F')))
+					// exponent...
+					|| str[j] == 'e'
+						|| str[j] == 'E')){
+			// exponent sign...
+			if('eE'.includes(str[j]) 
+				&& '+-'.includes(str[j+1])){
+				j++ }
 			j++ }
 		// BigInt...
 		if(str[j] == 'n'){

package/test.js

@@ -45,6 +45,12 @@ var setups = test.Setups({
 		return ['123', json] },
 	'number-neg': function(assert){
 		return ['-123', json] },
+	//'number-pos': function(assert){
+	//	return ['+123', json] },
+	'number-exp': function(assert){
+		return ['1e+100', json] },
+	'number-exp-neg': function(assert){
+		return ['1e-100', json] },
 	'number-zero': function(assert){
 		return ['0', json] },
 	'float-a': function(assert){
@@ -68,7 +74,8 @@ var setups = test.Setups({
 	// XXX also test diffrerent quotations...
 	string: function(assert){
 		return ['"string"', json] },
-	// XXX ERR this breaks...
+	'string-empty': function(assert){
+		return ['""', json] },
 	'string-multiline': function(assert){
 		return ['"string\\nstring\\nstring"', json] },
 
@@ -106,7 +113,6 @@ var setups = test.Setups({
 		return ['Map([[<RECURSIVE[]>,"value"]])'] },
 	'map-recursive-value': function(assert){
 		return ['Map([["key",<RECURSIVE[]>]])'] },
-
 })
 
 test.Modifiers({
@@ -170,7 +176,6 @@ test.Tests({
 		// XXX
 	},
 
-	//* XXX ERR
 	'partial-deep-copy': function(assert, [setup]){
 		var obj = eJSON.deserialize(setup, true)
 		var funcs = []
@@ -185,12 +190,13 @@ test.Tests({
 })
 
 test.Cases({
-	/* XXX for some magical reason hese break as soon as we add [setup] to arguments...
-	'deep-copy-function': function(assert, [setup]){
-		// XXX check function isolation...
-	},
-	//*/
-
+	//
+	// Format:
+	// 	[
+	// 		[ "<extended-syntax>", "<JSON-syntax>" ],
+	// 		...
+	// 	]
+	//
 	// NOTE: these syntax variants are not output by .serialize(..) this it
 	// 		is less critical to test them in the main loop.
 	// 		XXX though it would be nice to do so...
@@ -198,10 +204,20 @@ test.Cases({
 		// numbers/floats...
 		['.123', '0.123'],
 		['123.', '123'],
+		['+123', '123'],
+		['123e100', '123e+100'],
+		['123E100', '123e+100'],
+		['0xff', '255'],
+		['0Xff', '255'],
+		['0o77', '63'],
+		['0O77', '63'],
+		['0b11', '3'],
+		['0B11', '3'],
 
 		// string quotes...
-		['"abc"', "'abc'"],
-		['"abc"', '`abc`'],
+		// XXX test new lines...
+		["'abc'", '"abc"'],
+		['`abc`', '"abc"'],
 
 		// arrays...
 		['[1,2,]', '[1,2]'],
@@ -218,12 +234,46 @@ test.Cases({
 				`"${ a }" and "${ b }" should deserialize to the samve value.`,
 					'got:', aa, 'and', bb, 'resp.') } },
 
+	_make_object_with_methods: function(){
+		var in_closure = 123
+		return {
+			stateful: function(){
+				return typeof(in_closure) != 'undefined' ?
+		   			'state_retained'
+					: 'state_lost' },
+			stateless: function(){
+				return 'stateless' },
+		} },
 	'deep-copy-function': function(assert){
-		// XXX check function isolation...
-	},
+		var obj = this._make_object_with_methods()
+		var obj_copy = eJSON.deepCopy(obj, true)
+
+		// sanity checks...
+		assert(obj.stateless() == 'stateless')
+		assert(obj.stateful() == 'state_retained')
+		assert(obj_copy.stateless() == 'stateless')
+
+		// context should be lost...
+		assert(
+			obj_copy.stateful() == 'state_lost',
+			'Function closure not lost.')
+		assert(obj.stateful !== obj_copy.stateful,
+			'Function objects retained.') },
 	'partial-deep-copy-function': function(assert){
-		// XXX check function isolation...
-	},
+		var obj = this._make_object_with_methods()
+		var obj_copy = eJSON.partialDeepCopy(obj)
+
+		// sanity checks...
+		assert(obj.stateless() == 'stateless')
+		assert(obj.stateful() == 'state_retained')
+		assert(obj_copy.stateless() == 'stateless')
+
+		// context should be retained...
+		assert(
+			obj_copy.stateful() == 'state_retained',
+			'Function closure lost.') 
+		assert(obj.stateful === obj_copy.stateful,
+			'Function objects not retained.') },
 })