├── .travis.yml
├── CONTRIBUTORS.md
├── LICENSE.md
├── Makefile
├── README.md
├── icon.png
├── main.js
├── package.js
├── package.json
└── test
    └── test.js


/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - 0.8
4 |   - '0.10'


--------------------------------------------------------------------------------
/CONTRIBUTORS.md:
--------------------------------------------------------------------------------
 1 | * Rodrigo González ([roro89](https://github.com/roro89))
 2 | * ([b123400](https://github.com/b123400))
 3 | * ([tomByrer](https://github.com/tomByrer))
 4 | * WebGap ([lihe1314](https://github.com/lihe1314))
 5 | * Joseph Jung ([ozymandias547](https://github.com/ozymandias547))
 6 | * ([lskrabonja](https://github.com/lskrabonja))
 7 | * Devin Weaver ([sukima](https://github.com/sukima))
 8 | * Craig Andrews ([candrews](https://github.com/candrews))
 9 | * Oleg Sklyanchuk ([olegskl](https://github.com/olegskl))
10 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | # LICENCE
 2 | 
 3 | The MIT License (MIT)
 4 | Copyright (c) 2013 Rodrigo González, Sapienlab
 5 | 
 6 | Permission is hereby granted, free of charge, to any
 7 | person obtaining a copy of this software and associated
 8 | documentation files (the "Software"), to deal in the
 9 | Software without restriction, including without limitation
10 | the rights to use, copy, modify, merge, publish,
11 | distribute, sublicense, and/or sell copies of the
12 | Software, and to permit persons to whom the Software is
13 | furnished to do so, subject to the following conditions:
14 | 
15 | The above copyright notice and this permission notice
16 | shall be included in all copies or substantial portions of
17 | the Software.
18 | 
19 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
20 | KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
21 | WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
22 | PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
23 | OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
25 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | TESTS = test/*.js
2 | 
3 | test:
4 | 	@./node_modules/.bin/mocha \
5 | 		$(TESTS) -R spec
6 | 
7 | .PHONY: test bench


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![Build Status](https://secure.travis-ci.org/sapienlab/jsonpack.png)](http://travis-ci.org/sapienlab/jsonpack)
  2 | # jsonpack <img src=https://raw.githubusercontent.com/sapienlab/jsonpack/master/icon.png alt="icon for jsonpack compressor">
  3 | 
  4 | A compression algorithm for JSON
  5 | 
  6 | ## Introduction
  7 | 
  8 | jsonpack is a JavaScript program to pack and unpack JSON data.
  9 | 
 10 | It can compress to 55% of original size if the data has a recursive structure, example 
 11 | [Earthquake GeoJSON](http://earthquake.usgs.gov/earthquakes/feed/geojson/2.5/month) or 
 12 | [Twitter API](http://search.twitter.com/search.json?q=Twitter%20API&result_type=mixed). 
 13 | 
 14 | This lib works in both Node.js and browsers (older browsers missing [ES5's JSON.stringify](http://caniuse.com/json) support will need a [shim](http://bestiejs.github.io/json3/)).
 15 | 
 16 | **Quick example**
 17 | ```javascript
 18 | // big JSON
 19 | var json = {...}
 20 | 
 21 | // pack the big JSON 
 22 | var packed = jsonpack.pack(json);
 23 | 
 24 | // do stuff...
 25 | 
 26 | // And then unpack the packed
 27 | var json = jsonpack.unpack(packed);
 28 | ```
 29 | 
 30 | ## Installation
 31 | 
 32 | **jsonpack** can be installed via [cpm][cpm], [volo][volo] or [npm][npm], or simply [downloaded][download].
 33 | 
 34 | Via cpm:
 35 | 
 36 | ```bash
 37 | $ cpm install jsonpack
 38 | ```
 39 | 
 40 | Via volo:
 41 | 
 42 | ```bash
 43 | $ volo add sapienlab/jsonpack
 44 | ```
 45 | 
 46 | Via npm:
 47 | 
 48 | ```bash
 49 | $ npm install jsonpack
 50 | ```
 51 | 
 52 | ## API
 53 | 
 54 | ### Attributes
 55 | 
 56 | #### jsonpack.JSON
 57 | A object that implements the JSON.parse() and JSON.stringify() members.
 58 | By default is the native JSON implemented in ECMAscript 5.
 59 | 
 60 | ### Members
 61 | 
 62 | #### jsonpack.pack(json, options)
 63 | Retrieve a packed representation of the json
 64 | 
 65 | ** Parameters **
 66 | 
 67 | * json {Object|string}: A valid JSON Object or their string representation
 68 | * parameters {[Object]}: A optional object
 69 | 	* verbose (devault is false): If is true, print a log message to the console at each step of packing
 70 | 		* example: `jsonpack.pack(json, { verbose: true });` packs with verbose only
 71 | 	* debug {[boolean=false]}: If is true, return a object with the internal representation of the
 72 |                              parser dictionary and the AST
 73 | 		* example: `jsonpack.pack(json, { debug: true });` packs with debug only
 74 | 
 75 | ** Returns:** 
 76 | 
 77 | * string: the packed string representation of the data
 78 | * object: if parameters.debug is true
 79 | 
 80 | ##### Examples
 81 | 
 82 | * Example 1: Node.js
 83 | 
 84 | ```javascript
 85 | // Example in node.js, read a file with JSON content and save another file
 86 | // with the packed representation of that JSON
 87 | var jsonpack = require('jsonpack/main'),
 88 |     fs       = require('fs');
 89 |     
 90 | // read a file called myBigJSON.json and execute with 
 91 | // jsonContent as the content of the file
 92 | fs.readFile('../data/bigData.json', 'utf8', function(error, jsonContent) {
 93 |     
 94 |     // packed now is a string with the packed version of jsonContent
 95 |     var packed = jsonpack.pack(jsonContent);
 96 |     
 97 |     // save the packed in a file
 98 |     fs.writeFile('../data/packed.txt', packed);
 99 |     
100 | });
101 | ```
102 | 
103 | * Example 2: Browser/Node.js with AMD
104 | 
105 | ```javascript
106 | require(['jsonpack', 'text!../data/bigData.json'], function(jsonpack, jsonContent) {
107 | 
108 | 	// packed the data
109 | 	var packed = jsonpack.pack(jsonContent);
110 | 	
111 | 	// Do stuff with the packed string
112 |     console.log(packed);
113 | });
114 | ```
115 | 
116 | * Example 3: Browser
117 | 
118 | ```html
119 | <script src="path/to/jsonpack/main.js" />
120 | <script>
121 |  var json = {
122 |  	type : 'world',
123 |  	name: 'earth',
124 |  	children: [{
125 |  		type: 'continent',
126 |  		name: 'America',
127 |  		children: [{
128 |  			type : 'country',
129 |  			name : 'Chile',
130 |  			children: [{
131 |  				type : 'commune',
132 |  				name : 'Antofagasta'
133 |  			}]
134 |  		}]
135 |  	}, {
136 |  		type: 'continent',
137 |  		name : 'Europe'
138 |  	}]
139 |  };
140 |  	
141 |  var packed = jsonpack.pack(json);
142 |  
143 |  console.log(packed);
144 |  // print:
145 |  // "type|world|name|earth|children|continent|America|country|Chile|commune|Antofagasta|Europe^^^$0|1|2|3|4|@$0|5|2|6|4|@$0|7|2|8|4|@$0|9|2|A]]]]]|$0|5|2|B]]]"
146 | 
147 |  
148 | </script>
149 | ```
150 | 
151 | #### jsonpack.unpack(packed, options)
152 | 
153 | Unpack the data in the *packed* parameter
154 | 
155 | ** Parameters **
156 | 
157 | * packed {string} : The result of call jsonpack.packed(...)
158 | * options {[Object]}: Optional object
159 | 	* verbose (default: false) print a log message to the console at each step of packing  
160 | 
161 | ** Return: ** Object, the clone of the original JSON
162 | 
163 | ##### Examples
164 | 
165 | * Example 1: Node.js
166 | 
167 | ```javascript
168 | // Example in node.js, read a file with packed content and save another file
169 | // with the string representation of the original JSON
170 | var jsonpack = require('jsonpack/main'),
171 |     fs       = require('fs');
172 |     
173 | // read a file called packedjson and execute with 
174 | // packed as the content of the file
175 | fs.readFile('../data/packed.txt', 'utf8', function(error, packed) {
176 |     
177 |     // data now is a JavaScript Object of the original JSON
178 |     var data = jsonpack.unpack(jsonContent);
179 |     
180 |     // save the JSON in a file. data is a Javascript Object, so must be
181 |     // stringifed (and pretty print the JSON with 2 space indents).
182 |     fs.writeFile('../data/unpacked.json', JSON.stringify(data, null, 2));
183 |     
184 | });
185 | ```
186 | 
187 | * Example 2: Browser/Node.js with AMD
188 | 
189 | ```javascript
190 | require(['jsonpack', 'text!../data/packed'], function(jsonpack, packed) {
191 | 
192 | 	// unpacked the data
193 | 	// json now is a clone of the original JSON
194 | 	var json = jsonpack.unpack(packed);
195 | 	
196 | 	// Do stuff with the JavaScript object
197 |     console.log(json);
198 | });
199 | 
200 | ```
201 | 
202 | * Example 3: Browser
203 | 
204 | ```html
205 | <script src="path/to/jsonpack/main.js" />
206 | <script>
207 |  var packed = "type|world|name|earth|children|continent|America|country|Chile|commune|Antofagasta|Europe^^^$0|1|2|3|4|@$0|5|2|6|4|@$0|7|2|8|4|@$0|9|2|A]]]]]|$0|5|2|B]]]" 
208 | 
209 |  // unpack the packed to a clone of the original JSON 	
210 |  var json = jsonpack.unpack(packed);
211 |  
212 |  console.log(json);
213 |  
214 | </script>
215 | ```
216 | 
217 | ## FAQ
218 | ### This library is stable?
219 | Yes, was tested in Node.js, Chrome and Firefox.
220 | 
221 | ### How to contribute?
222 | I'm not a native English speaker, so create a issue or better a pull request for all of my grammatical errors :)
223 | As well, if you have a code issue or suggestion, create a issue, Thanks!
224 | 
225 | ### What about the icon?
226 | The icon is a generic (LGPL) icon by David Vignoni - http://www.icon-king.com/
227 | 
228 | ## LICENCE
229 | 
230 | The MIT License (MIT)
231 | Copyright (c) 2013 Rodrigo González, Sapienlab
232 | 
233 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
234 | 
235 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
236 | 
237 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
238 | 
239 | [cpm]: https://github.org/kriszyp/cpm
240 | [volo]: http://volojs.org/
241 | [npm]: http://npmjs.org/
242 | [download]: https://github.com/sapienlab/jsonpack/archive/master.zip
243 | 


--------------------------------------------------------------------------------
/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rgcl/jsonpack/adad9ffc76ed1e63e39387bd2f61961fa1a6e2a0/icon.png


--------------------------------------------------------------------------------
/main.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  Copyright (c) 2013, Rodrigo González, Sapienlab All Rights Reserved.
  3 |  Available via MIT LICENSE. See https://github.com/roro89/jsonpack/blob/master/LICENSE.md for details.
  4 |  */
  5 | (function(define) {
  6 | 
  7 | 	define([], function() {
  8 | 
  9 | 		var TOKEN_TRUE = -1;
 10 | 		var TOKEN_FALSE = -2;
 11 | 		var TOKEN_NULL = -3;
 12 | 		var TOKEN_EMPTY_STRING = -4;
 13 | 		var TOKEN_UNDEFINED = -5;
 14 | 
 15 | 		var pack = function(json, options) {
 16 | 
 17 | 			// Canonizes the options
 18 | 			options = options || {};
 19 | 
 20 | 			// A shorthand for debugging
 21 | 			var verbose = options.verbose || false;
 22 | 
 23 | 			verbose && console.log('Normalize the JSON Object');
 24 | 
 25 | 			// JSON as Javascript Object (Not string representation)
 26 | 			json = typeof json === 'string' ? this.JSON.parse(json) : json;
 27 | 
 28 | 			verbose && console.log('Creating a empty dictionary');
 29 | 
 30 | 			// The dictionary
 31 | 			var dictionary = {
 32 | 				strings : [],
 33 | 				integers : [],
 34 | 				floats : []
 35 | 			};
 36 | 
 37 | 			verbose && console.log('Creating the AST');
 38 | 
 39 | 			// The AST
 40 | 			var ast = (function recursiveAstBuilder(item) {
 41 | 
 42 | 				verbose && console.log('Calling recursiveAstBuilder with ' + this.JSON.stringify(item));
 43 | 
 44 | 				// The type of the item
 45 | 				var type = typeof item;
 46 | 
 47 | 				// Case 7: The item is null
 48 | 				if (item === null) {
 49 | 					return {
 50 | 						type : 'null',
 51 | 						index : TOKEN_NULL
 52 | 					};
 53 | 				}
 54 | 				
 55 | 				//add undefined 
 56 | 				if (typeof item === 'undefined') {
 57 | 					return {
 58 | 						type : 'undefined',
 59 | 						index : TOKEN_UNDEFINED
 60 | 					};
 61 | 				}
 62 | 
 63 | 				// Case 1: The item is Array Object
 64 | 				if ( item instanceof Array) {
 65 | 
 66 | 					// Create a new sub-AST of type Array (@)
 67 | 					var ast = ['@'];
 68 | 
 69 | 					// Add each items
 70 | 					for (var i in item) {
 71 | 						
 72 | 						if (!item.hasOwnProperty(i)) continue;
 73 | 
 74 | 						ast.push(recursiveAstBuilder(item[i]));
 75 | 					}
 76 | 
 77 | 					// And return
 78 | 					return ast;
 79 | 
 80 | 				}
 81 | 
 82 | 				// Case 2: The item is Object
 83 | 				if (type === 'object') {
 84 | 
 85 | 					// Create a new sub-AST of type Object ($)
 86 | 					var ast = ['$'];
 87 | 
 88 | 					// Add each items
 89 | 					for (var key in item) {
 90 | 
 91 | 						if (!item.hasOwnProperty(key))
 92 | 							continue;
 93 | 
 94 | 						ast.push(recursiveAstBuilder(key));
 95 | 						ast.push(recursiveAstBuilder(item[key]));
 96 | 					}
 97 | 
 98 | 					// And return
 99 | 					return ast;
100 | 
101 | 				}
102 | 
103 | 				// Case 3: The item empty string
104 | 				if (item === '') {
105 | 					return {
106 | 						type : 'empty',
107 | 						index : TOKEN_EMPTY_STRING
108 | 					};
109 | 				}
110 | 
111 | 				// Case 4: The item is String
112 | 				if (type === 'string') {
113 | 
114 | 					// The index of that word in the dictionary
115 | 					var index = _indexOf.call(dictionary.strings, item);
116 | 
117 | 					// If not, add to the dictionary and actualize the index
118 | 					if (index == -1) {
119 | 						dictionary.strings.push(_encode(item));
120 | 						index = dictionary.strings.length - 1;
121 | 					}
122 | 
123 | 					// Return the token
124 | 					return {
125 | 						type : 'strings',
126 | 						index : index
127 | 					};
128 | 				}
129 | 
130 | 				// Case 5: The item is integer
131 | 				if (type === 'number' && item % 1 === 0) {
132 | 
133 | 					// The index of that number in the dictionary
134 | 					var index = _indexOf.call(dictionary.integers, item);
135 | 
136 | 					// If not, add to the dictionary and actualize the index
137 | 					if (index == -1) {
138 | 						dictionary.integers.push(_base10To36(item));
139 | 						index = dictionary.integers.length - 1;
140 | 					}
141 | 
142 | 					// Return the token
143 | 					return {
144 | 						type : 'integers',
145 | 						index : index
146 | 					};
147 | 				}
148 | 
149 | 				// Case 6: The item is float
150 | 				if (type === 'number') {
151 | 					// The index of that number in the dictionary
152 | 					var index = _indexOf.call(dictionary.floats, item);
153 | 
154 | 					// If not, add to the dictionary and actualize the index
155 | 					if (index == -1) {
156 | 						// Float not use base 36
157 | 						dictionary.floats.push(item);
158 | 						index = dictionary.floats.length - 1;
159 | 					}
160 | 
161 | 					// Return the token
162 | 					return {
163 | 						type : 'floats',
164 | 						index : index
165 | 					};
166 | 				}
167 | 
168 | 				// Case 7: The item is boolean
169 | 				if (type === 'boolean') {
170 | 					return {
171 | 						type : 'boolean',
172 | 						index : item ? TOKEN_TRUE : TOKEN_FALSE
173 | 					};
174 | 				}
175 | 
176 | 				// Default
177 | 				throw new Error('Unexpected argument of type ' + typeof (item));
178 | 
179 | 			})(json);
180 | 
181 | 			// A set of shorthands proxies for the length of the dictionaries
182 | 			var stringLength = dictionary.strings.length;
183 | 			var integerLength = dictionary.integers.length;
184 | 			var floatLength = dictionary.floats.length;
185 | 
186 | 			verbose && console.log('Parsing the dictionary');
187 | 
188 | 			// Create a raw dictionary
189 | 			var packed = dictionary.strings.join('|');
190 | 			packed += '^' + dictionary.integers.join('|');
191 | 			packed += '^' + dictionary.floats.join('|');
192 | 
193 | 			verbose && console.log('Parsing the structure');
194 | 
195 | 			// And add the structure
196 | 			packed += '^' + (function recursiveParser(item) {
197 | 
198 | 				verbose && console.log('Calling a recursiveParser with ' + this.JSON.stringify(item));
199 | 
200 | 				// If the item is Array, then is a object of
201 | 				// type [object Object] or [object Array]
202 | 				if ( item instanceof Array) {
203 | 
204 | 					// The packed resulting
205 | 					var packed = item.shift();
206 | 
207 | 					for (var i in item) {
208 | 						
209 | 						if (!item.hasOwnProperty(i)) 
210 | 							continue;
211 | 						
212 | 						packed += recursiveParser(item[i]) + '|';
213 | 					}
214 | 
215 | 					return (packed[packed.length - 1] === '|' ? packed.slice(0, -1) : packed) + ']';
216 | 
217 | 				}
218 | 
219 | 				// A shorthand proxies
220 | 				var type = item.type, index = item.index;
221 | 
222 | 				if (type === 'strings') {
223 | 					// Just return the base 36 of index
224 | 					return _base10To36(index);
225 | 				}
226 | 
227 | 				if (type === 'integers') {
228 | 					// Return a base 36 of index plus stringLength offset
229 | 					return _base10To36(stringLength + index);
230 | 				}
231 | 
232 | 				if (type === 'floats') {
233 | 					// Return a base 36 of index plus stringLength and integerLength offset
234 | 					return _base10To36(stringLength + integerLength + index);
235 | 				}
236 | 
237 | 				if (type === 'boolean') {
238 | 					return item.index;
239 | 				}
240 | 
241 | 				if (type === 'null') {
242 | 					return TOKEN_NULL;
243 | 				}
244 | 
245 | 				if (type === 'undefined') {
246 | 					return TOKEN_UNDEFINED;
247 | 				}
248 | 
249 | 				if (type === 'empty') {
250 | 					return TOKEN_EMPTY_STRING;
251 | 				}
252 | 
253 | 				throw new TypeError('The item is alien!');
254 | 
255 | 			})(ast);
256 | 
257 | 			verbose && console.log('Ending parser');
258 | 
259 | 			// If debug, return a internal representation of dictionary and stuff
260 | 			if (options.debug)
261 | 				return {
262 | 					dictionary : dictionary,
263 | 					ast : ast,
264 | 					packed : packed
265 | 				};
266 | 
267 | 			return packed;
268 | 
269 | 		};
270 | 
271 | 		var unpack = function(packed, options) {
272 | 
273 | 			// Canonizes the options
274 | 			options = options || {};
275 | 
276 | 			// A raw buffer
277 | 			var rawBuffers = packed.split('^');
278 | 
279 | 			// Create a dictionary
280 | 			options.verbose && console.log('Building dictionary');
281 | 			var dictionary = [];
282 | 
283 | 			// Add the strings values
284 | 			var buffer = rawBuffers[0];
285 | 			if (buffer !== '') {
286 | 				buffer = buffer.split('|');
287 | 				options.verbose && console.log('Parse the strings dictionary');
288 | 				for (var i=0, n=buffer.length; i<n; i++){
289 | 					dictionary.push(_decode(buffer[i]));
290 | 				}
291 | 			}
292 | 
293 | 			// Add the integers values
294 | 			buffer = rawBuffers[1];
295 | 			if (buffer !== '') {
296 | 				buffer = buffer.split('|');
297 | 				options.verbose && console.log('Parse the integers dictionary');
298 | 				for (var i=0, n=buffer.length; i<n; i++){
299 | 					dictionary.push(_base36To10(buffer[i]));
300 | 				}
301 | 			}
302 | 
303 | 			// Add the floats values
304 | 			buffer = rawBuffers[2];
305 | 			if (buffer !== '') {
306 | 				buffer = buffer.split('|')
307 | 				options.verbose && console.log('Parse the floats dictionary');
308 | 				for (var i=0, n=buffer.length; i<n; i++){
309 | 					dictionary.push(parseFloat(buffer[i]));
310 | 				}
311 | 			}
312 | 			// Free memory
313 | 			buffer = null;
314 | 
315 | 			options.verbose && console.log('Tokenizing the structure');
316 | 
317 | 			// Tokenizer the structure
318 | 			var number36 = '';
319 | 			var tokens = [];
320 | 			var len=rawBuffers[3].length;
321 | 			for (var i = 0; i < len; i++) {
322 | 				var symbol = rawBuffers[3].charAt(i);
323 | 				if (symbol === '|' || symbol === '$' || symbol === '@' || symbol === ']') {
324 | 					if (number36) {
325 | 						tokens.push(_base36To10(number36));
326 | 						number36 = '';
327 | 					}
328 | 					symbol !== '|' && tokens.push(symbol);
329 | 				} else {
330 | 					number36 += symbol;
331 | 				}
332 | 			}
333 | 
334 | 			// A shorthand proxy for tokens.length
335 | 			var tokensLength = tokens.length;
336 | 
337 | 			// The index of the next token to read
338 | 			var tokensIndex = 0;
339 | 
340 | 			options.verbose && console.log('Starting recursive parser');
341 | 
342 | 			return (function recursiveUnpackerParser() {
343 | 
344 | 				// Maybe '$' (object) or '@' (array)
345 | 				var type = tokens[tokensIndex++];
346 | 
347 | 				options.verbose && console.log('Reading collection type ' + (type === '$' ? 'object' : 'Array'));
348 | 
349 | 				// Parse an array
350 | 				if (type === '@') {
351 | 
352 | 					var node = [];
353 | 
354 | 					for (; tokensIndex < tokensLength; tokensIndex++) {
355 | 						var value = tokens[tokensIndex];
356 | 						options.verbose && console.log('Read ' + value + ' symbol');
357 | 						if (value === ']')
358 | 							return node;
359 | 						if (value === '@' || value === '$') {
360 | 							node.push(recursiveUnpackerParser());
361 | 						} else {
362 | 							switch(value) {
363 | 								case TOKEN_TRUE:
364 | 									node.push(true);
365 | 									break;
366 | 								case TOKEN_FALSE:
367 | 									node.push(false);
368 | 									break;
369 | 								case TOKEN_NULL:
370 | 									node.push(null);
371 | 									break;
372 | 								case TOKEN_UNDEFINED:
373 | 									node.push(undefined);
374 | 									break;
375 | 								case TOKEN_EMPTY_STRING:
376 | 									node.push('');
377 | 									break;
378 | 								default:
379 | 									node.push(dictionary[value]);
380 | 							}
381 | 
382 | 						}
383 | 					}
384 | 
385 | 					options.verbose && console.log('Parsed ' + this.JSON.stringify(node));
386 | 
387 | 					return node;
388 | 
389 | 				}
390 | 
391 | 				// Parse a object
392 | 				if (type === '$') {
393 | 					var node = {};
394 | 
395 | 					for (; tokensIndex < tokensLength; tokensIndex++) {
396 | 
397 | 						var key = tokens[tokensIndex];
398 | 
399 | 						if (key === ']')
400 | 							return node;
401 | 
402 | 						if (key === TOKEN_EMPTY_STRING)
403 | 							key = '';
404 | 						else
405 | 							key = dictionary[key];
406 | 
407 | 						var value = tokens[++tokensIndex];
408 | 
409 | 						if (value === '@' || value === '$') {
410 | 							node[key] = recursiveUnpackerParser();
411 | 						} else {
412 | 							switch(value) {
413 | 								case TOKEN_TRUE:
414 | 									node[key] = true;
415 | 									break;
416 | 								case TOKEN_FALSE:
417 | 									node[key] = false;
418 | 									break;
419 | 								case TOKEN_NULL:
420 | 									node[key] = null;
421 | 									break;
422 | 								case TOKEN_UNDEFINED:
423 | 									node[key] = undefined;
424 | 									break;
425 | 								case TOKEN_EMPTY_STRING:
426 | 									node[key] = '';
427 | 									break;
428 | 								default:
429 | 									node[key] = dictionary[value];
430 | 							}
431 | 
432 | 						}
433 | 					}
434 | 
435 | 					options.verbose && console.log('Parsed ' + this.JSON.stringify(node));
436 | 
437 | 					return node;
438 | 				}
439 | 
440 | 				throw new TypeError('Bad token ' + type + ' isn\'t a type');
441 | 
442 | 			})();
443 | 
444 | 		}
445 | 		/**
446 | 		 * Get the index value of the dictionary
447 | 		 * @param {Object} dictionary a object that have two array attributes: 'string' and 'number'
448 | 		 * @param {Object} data
449 | 		 */
450 | 		var _indexOfDictionary = function(dictionary, value) {
451 | 
452 | 			// The type of the value
453 | 			var type = typeof value;
454 | 
455 | 			// If is boolean, return a boolean token
456 | 			if (type === 'boolean')
457 | 				return value ? TOKEN_TRUE : TOKEN_FALSE;
458 | 
459 | 			// If is null, return a... yes! the null token
460 | 			if (value === null)
461 | 				return TOKEN_NULL;
462 | 
463 | 			//add undefined
464 | 			if (typeof value === 'undefined')
465 | 				return TOKEN_UNDEFINED;
466 | 
467 | 
468 | 			if (value === '') {
469 | 				return TOKEN_EMPTY_STRING;
470 | 			}
471 | 
472 | 			if (type === 'string') {
473 | 				value = _encode(value);
474 | 				var index = _indexOf.call(dictionary.strings, value);
475 | 				if (index === -1) {
476 | 					dictionary.strings.push(value);
477 | 					index = dictionary.strings.length - 1;
478 | 				}
479 | 			}
480 | 
481 | 			// If has an invalid JSON type (example a function)
482 | 			if (type !== 'string' && type !== 'number') {
483 | 				throw new Error('The type is not a JSON type');
484 | 			};
485 | 
486 | 			if (type === 'string') {// string
487 | 				value = _encode(value);
488 | 			} else if (value % 1 === 0) {// integer
489 | 				value = _base10To36(value);
490 | 			} else {// float
491 | 
492 | 			}
493 | 
494 | 			// If is number, "serialize" the value
495 | 			value = type === 'number' ? _base10To36(value) : _encode(value);
496 | 
497 | 			// Retrieve the index of that value in the dictionary
498 | 			var index = _indexOf.call(dictionary[type], value);
499 | 
500 | 			// If that value is not in the dictionary
501 | 			if (index === -1) {
502 | 				// Push the value
503 | 				dictionary[type].push(value);
504 | 				// And return their index
505 | 				index = dictionary[type].length - 1;
506 | 			}
507 | 
508 | 			// If the type is a number, then add the '+'  prefix character
509 | 			// to differentiate that they is a number index. If not, then
510 | 			// just return a 36-based representation of the index
511 | 			return type === 'number' ? '+' + index : index;
512 | 
513 | 		};
514 | 
515 | 		var _encode = function(str) {
516 | 			if ( typeof str !== 'string')
517 | 				return str;
518 | 
519 | 			return str.replace(/[\+ \|\^\%]/g, function(a) {
520 | 				return ({
521 | 				' ' : '+',
522 | 				'+' : '%2B',
523 | 				'|' : '%7C',
524 | 				'^' : '%5E',
525 | 				'%' : '%25'
526 | 				})[a]
527 | 			});
528 | 		};
529 | 
530 | 		var _decode = function(str) {
531 | 			if ( typeof str !== 'string')
532 | 				return str;
533 | 
534 | 			return str.replace(/\+|%2B|%7C|%5E|%25/g, function(a) {
535 | 				return ({
536 | 				'+' : ' ',
537 | 				'%2B' : '+',
538 | 				'%7C' : '|',
539 | 				'%5E' : '^',
540 | 				'%25' : '%'
541 | 				})[a]
542 | 			})
543 | 		};
544 | 
545 | 		var _base10To36 = function(number) {
546 | 			return Number.prototype.toString.call(number, 36).toUpperCase();
547 | 		};
548 | 
549 | 		var _base36To10 = function(number) {
550 | 			return parseInt(number, 36);
551 | 		};
552 | 
553 | 		var _indexOf = Array.prototype.indexOf ||
554 | 		function(obj, start) {
555 | 			for (var i = (start || 0), j = this.length; i < j; i++) {
556 | 				if (this[i] === obj) {
557 | 					return i;
558 | 				}
559 | 			}
560 | 			return -1;
561 | 		};
562 | 
563 | 		return {
564 | 			JSON : JSON,
565 | 			pack : pack,
566 | 			unpack : unpack
567 | 		};
568 | 
569 | 	});
570 | 
571 | })( typeof define == 'undefined' || !define.amd ? function(deps, factory) {
572 | 	var jsonpack = factory();
573 | 	if ( typeof exports != 'undefined')
574 | 		for (var key in jsonpack)
575 | 		exports[key] = jsonpack[key];
576 | 	else
577 | 		window.jsonpack = jsonpack;
578 | } : define);
579 | 


--------------------------------------------------------------------------------
/package.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  Copyright (c) 2013, Rodrigo González, Sapienlab All Rights Reserved.
 3 |  Available via MIT LICENSE, see https://github.com/roro89/jsonpack/blob/master/LICENSE.md for details.
 4 |  */
 5 | var miniExcludes = {
 6 | 		"jsonpack/README.md": 1,
 7 | 		"jsonpack/package": 1
 8 | 	},
 9 | 	isTestRe = /\/test\//;
10 | 
11 | var profile = {
12 | 	resourceTags: {
13 | 		test: function(filename, mid) {
14 | 			return isTestRe.test(filename);
15 | 		},
16 | 
17 | 		miniExclude: function(filename, mid){
18 | 			return isTestRe.test(filename) || mid in miniExcludes;
19 | 		},
20 | 
21 | 		amd: function(filename, mid){
22 | 			return /\.js$/.test(filename);
23 | 		}
24 | 	}
25 | };


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "jsonpack",
 3 | 	"author": "Rodrigo González | sapienlab",
 4 | 	"description": "A compression algorithm for JSON",
 5 | 	"version" : "1.1.5",
 6 | 	"licenses": [
 7 | 		{
 8 | 			"type": "MIT",
 9 | 			"url": "https://github.com/roro89/jsonpack/blob/master/LICENSE.md"
10 | 		}
11 | 	],
12 | 	"maintainers":[{
13 |    		"name": "Rodrigo González",
14 |    		"email": "rodrigo@sapienlab.com",
15 |    		"web" : "http://sapienlab.com"
16 | 	}],
17 | 	"repository": {
18 | 		"type": "git",
19 | 		"url": "https://github.com/sapienlab/jsonpack.git"
20 | 	},
21 | 	"keywords" : [
22 | 		"compress",
23 | 		"json"
24 | 	],
25 | 	"homepage" : "https://github.com/sapienlab/jsonpack",
26 | 	"readmeFilename" : "README.md",
27 | 	"main": "./main",
28 | 	"dojoBuild": "package.js",
29 | 	"icon" : "https://raw.github.com/sapienlab/jsonpack/master/icon.png",
30 | 	"volo" : {
31 | 		"baseDir" : "."		
32 | 	},
33 | 	"devDependencies": {
34 | 		"mocha": "*",
35 | 		"expect.js" : "*"
36 | 	},
37 | 	"scripts": {
38 | 		"test": "make test"
39 | 	}
40 | }
41 | 


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  Copyright (c) 2013, Rodrigo González, Sapienlab All Rights Reserved.
  3 |  Available via MIT LICENSE. See https://github.com/roro89/jsonpack/blob/master/LICENSE.md for details.
  4 |  */
  5 | 'use strict';
  6 | 
  7 | describe('jsonpack', function() {
  8 |     
  9 |     var assert = require('assert'),
 10 |         expect = require('expect.js'),
 11 |         jsonpack = require('../main.js');
 12 |     
 13 |     var plainObject = {
 14 |             "string" : "hello",
 15 |             "integer" : 1989,
 16 |             "float" : 1.2,
 17 |             "true" : true,
 18 |             "false" : false,
 19 |             "null" : null
 20 |         },
 21 |         plainObjectPacked = "string|hello|integer|float|true|false|null^1J9^1.2^$0|1|2|7|3|8|4|-1|5|-2|6|-3]";
 22 | 
 23 |     var deepObject = {
 24 |             attr1 : plainObject,
 25 |             attr2 : plainObject,
 26 |             attr3 : [plainObject, plainObject]
 27 |         },
 28 |         deepObjectPacked = "attr1|string|hello|integer|float|true|false|null|attr2|attr3^1J9|1J9|1J9|1J9^1.2^$0|$1|2|3|A|4|E|5|-1|6|-2|7|-3]|8|$1|2|3|B|4|E|5|-1|6|-2|7|-3]|9|@$1|2|3|C|4|E|5|-1|6|-2|7|-3]|$1|2|3|D|4|E|5|-1|6|-2|7|-3]]]";
 29 | 
 30 |     var arrayObject = [
 31 |             plainObject,
 32 |             deepObject
 33 |         ],
 34 |         arrayObjectPacked = "string|hello|integer|float|true|false|null|attr1|attr2|attr3^1J9|1J9|1J9|1J9|1J9^1.2^@$0|1|2|A|3|F|4|-1|5|-2|6|-3]|$7|$0|1|2|B|3|F|4|-1|5|-2|6|-3]|8|$0|1|2|C|3|F|4|-1|5|-2|6|-3]|9|@$0|1|2|D|3|F|4|-1|5|-2|6|-3]|$0|1|2|E|3|F|4|-1|5|-2|6|-3]]]]";
 35 | 
 36 |     describe('elemental', function() {
 37 | 
 38 |         it('is object', function() {
 39 |             expect(jsonpack).to.be.an("object");
 40 |         });
 41 | 
 42 |         it('has JSON property', function() {
 43 |             expect(jsonpack.JSON).to.be.an("object");
 44 |         });
 45 | 
 46 |         it('has pack method', function() {
 47 |             expect(jsonpack.pack).to.be.a("function");
 48 |         });
 49 | 
 50 |         it('has unpack method', function() {
 51 |             expect(jsonpack.unpack).to.be.a("function");
 52 |         });
 53 | 
 54 |     });
 55 | 
 56 |     describe('pack', function() {
 57 | 
 58 |         it('empty object', function() {
 59 |             expect(jsonpack.pack({})).to.eql("^^^$]");
 60 |         });
 61 | 
 62 |         it('empty array', function() {
 63 |             expect(jsonpack.pack([])).to.eql("^^^@]");
 64 |         });
 65 | 
 66 |         it('plain object', function() {
 67 |             expect(jsonpack.pack(plainObject)).to.eql(plainObjectPacked);
 68 |         });
 69 | 
 70 |         it('deep object', function() {
 71 |             expect(jsonpack.pack(deepObject)).to.eql(deepObjectPacked);
 72 |         });
 73 | 
 74 |         it('complex array object', function() {
 75 |             expect(jsonpack.pack(arrayObject)).to.eql(arrayObjectPacked);
 76 |         });
 77 | 
 78 |     });
 79 | 
 80 |     describe('unpack', function() {
 81 | 
 82 |         it('empty object', function() {
 83 |             expect(jsonpack.unpack("^^^$]")).to.eql({});
 84 |         });
 85 | 
 86 |         it('empty array', function() {
 87 |             expect(jsonpack.unpack("^^^@]")).to.eql([]);
 88 |         });
 89 | 
 90 |         it('plain object', function() {
 91 |             expect(jsonpack.unpack(plainObjectPacked)).to.eql(plainObject);
 92 |         });
 93 | 
 94 |         it('deep object', function() {
 95 |             expect(jsonpack.unpack(deepObjectPacked)).to.eql(deepObject);
 96 |         });
 97 | 
 98 |         it('complex array object', function() {
 99 |             expect(jsonpack.unpack(arrayObjectPacked)).to.eql(arrayObject);
100 |         });
101 | 
102 |     });
103 | 
104 | });
105 | 


--------------------------------------------------------------------------------