pax_global_header00006660000000000000000000000064126724605710014524gustar00rootroot0000000000000052 comment=c58c026a58dd0b71401f7aa99e891291a60820e3 json5-0.5.0/000077500000000000000000000000001267246057100125645ustar00rootroot00000000000000json5-0.5.0/.editorconfig000066400000000000000000000005351267246057100152440ustar00rootroot00000000000000# Don't allow rules from further up the tree. root = true [*] # Every file end_of_line = lf # Unix sytle line endings insert_final_newline = true # Ensure a new line at the end of each file indent_style = space # Use spaces instead of tabs indent_size = 4 # Indent 4 spaces json5-0.5.0/.gitignore000066400000000000000000000000331267246057100145500ustar00rootroot00000000000000node_modules npm-debug.log json5-0.5.0/.jshintrc000066400000000000000000000000461267246057100144110ustar00rootroot00000000000000{ "browser": true, "node": true } json5-0.5.0/.travis.yml000066400000000000000000000001151267246057100146720ustar00rootroot00000000000000sudo: false language: node_js node_js: - "0.10" - "0.12" - "4" - "5" json5-0.5.0/CHANGELOG.md000066400000000000000000000135701267246057100144030ustar00rootroot00000000000000### v0.5.0 [[code][c0.5.0], [diff][d0.5.0]] [c0.5.0]: https://github.com/aseemk/json5/tree/v0.5.0 [d0.5.0]: https://github.com/aseemk/json5/compare/v0.4.0...v0.5.0 This release includes major internal changes and public API enhancements. - **Major:** JSON5 officially supports Node.js v4 LTS and v5. Support for Node.js v0.6 and v0.8 have been dropped, while support for v0.10 and v0.12 remain. - Fix: YUI Compressor no longer fails when compressing json5.js. ([#97]) - New: `parse` and the CLI provide line and column numbers when displaying error messages. ([#101]; awesome work by [@amb26].) ### v0.4.0 [[code][c0.4.0], [diff][d0.4.0]] [c0.4.0]: https://github.com/aseemk/json5/tree/v0.4.0 [d0.4.0]: https://github.com/aseemk/json5/compare/v0.2.0...v0.4.0 Note that v0.3.0 was tagged, but never published to npm, so this v0.4.0 changelog entry includes v0.3.0 features. This is a massive release that adds `stringify` support, among other things. - **Major:** `JSON5.stringify()` now exists! This method is analogous to the native `JSON.stringify()`; it just avoids quoting keys where possible. See the [usage documentation](./README.md#usage) for more. ([#32]; huge thanks and props [@aeisenberg]!) - New: `NaN` and `-NaN` are now allowed number literals. ([#30]; thanks [@rowanhill].) - New: Duplicate object keys are now allowed; the last value is used. This is the same behavior as JSON. ([#57]; thanks [@jordanbtucker].) - Fix: Properly handle various whitespace and newline cases now. E.g. JSON5 now properly supports escaped CR and CRLF newlines in strings, and JSON5 now accepts the same whitespace as JSON (stricter than ES5). ([#58], [#60], and [#63]; thanks [@jordanbtucker].) - New: Negative hexadecimal numbers (e.g. `-0xC8`) are allowed again. (They were disallowed in v0.2.0; see below.) It turns out they *are* valid in ES5, so JSON5 supports them now too. ([#36]; thanks [@jordanbtucker]!) ### v0.2.0 [[code][c0.2.0], [diff][d0.2.0]] [c0.2.0]: https://github.com/aseemk/json5/tree/v0.2.0 [d0.2.0]: https://github.com/aseemk/json5/compare/v0.1.0...v0.2.0 This release fixes some bugs and adds some more utility features to help you express data more easily: - **Breaking:** Negative hexadecimal numbers (e.g. `-0xC8`) are rejected now. While V8 (e.g. Chrome and Node) supported them, it turns out they're invalid in ES5. This has been [fixed in V8][v8-hex-fix] (and by extension, Chrome and Node), so JSON5 officially rejects them now, too. ([#36]) - New: Trailing decimal points in decimal numbers are allowed again. (They were disallowed in v0.1.0; see below.) They're allowed by ES5, and differentiating between integers and floats may make sense on some platforms. ([#16]; thanks [@Midar].) - New: `Infinity` and `-Infinity` are now allowed number literals. ([#30]; thanks [@pepkin88].) - New: Plus signs (`+`) in front of numbers are now allowed, since it can be helpful in some contexts to explicitly mark numbers as positive. (E.g. when a property represents changes or deltas.) - Fix: unescaped newlines in strings are rejected now. ([#24]; thanks [@Midar].) ### v0.1.0 [[code][c0.1.0], [diff][d0.1.0]] [c0.1.0]: https://github.com/aseemk/json5/tree/v0.1.0 [d0.1.0]: https://github.com/aseemk/json5/compare/v0.0.1...v0.1.0 This release tightens JSON5 support and adds helpful utility features: - New: Support hexadecimal numbers. (Thanks [@MaxNanasy].) - Fix: Reject octal numbers properly now. Previously, they were accepted but improperly parsed as base-10 numbers. (Thanks [@MaxNanasy].) - **Breaking:** Reject "noctal" numbers now (base-10 numbers that begin with a leading zero). These are disallowed by both JSON5 and JSON, as well as by ES5's strict mode. (Thanks [@MaxNanasy].) - New: Support leading decimal points in decimal numbers. (Thanks [@MaxNanasy].) - **Breaking:** Reject trailing decimal points in decimal numbers now. These are disallowed by both JSON5 and JSON. (Thanks [@MaxNanasy].) - **Breaking:** Reject omitted elements in arrays now. These are disallowed by both JSON5 and JSON. - Fix: Throw proper `SyntaxError` instances on errors now. - New: Add Node.js `require()` hook. Register via `json5/lib/require`. - New: Add Node.js `json5` executable to compile JSON5 files to JSON. ### v0.0.1 [[code][c0.0.1], [diff][d0.0.1]] [c0.0.1]: https://github.com/aseemk/json5/tree/v0.0.1 [d0.0.1]: https://github.com/aseemk/json5/compare/v0.0.0...v0.0.1 This was the first implementation of this JSON5 parser. - Support unquoted object keys, including reserved words. Unicode characters and escape sequences sequences aren't yet supported. - Support single-quoted strings. - Support multi-line strings. - Support trailing commas in arrays and objects. - Support comments, both inline and block. ### v0.0.0 [[code](https://github.com/aseemk/json5/tree/v0.0.0)] Let's consider this to be Douglas Crockford's original [json_parse.js] — a parser for the regular JSON format. [json_parse.js]: https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js [v8-hex-fix]: http://code.google.com/p/v8/issues/detail?id=2240 [@MaxNanasy]: https://github.com/MaxNanasy [@Midar]: https://github.com/Midar [@pepkin88]: https://github.com/pepkin88 [@rowanhill]: https://github.com/rowanhill [@aeisenberg]: https://github.com/aeisenberg [@jordanbtucker]: https://github.com/jordanbtucker [@amb26]: https://github.com/amb26 [#16]: https://github.com/aseemk/json5/issues/16 [#24]: https://github.com/aseemk/json5/issues/24 [#30]: https://github.com/aseemk/json5/issues/30 [#32]: https://github.com/aseemk/json5/issues/32 [#36]: https://github.com/aseemk/json5/issues/36 [#57]: https://github.com/aseemk/json5/issues/57 [#58]: https://github.com/aseemk/json5/pull/58 [#60]: https://github.com/aseemk/json5/pull/60 [#63]: https://github.com/aseemk/json5/pull/63 [#97]: https://github.com/aseemk/json5/pull/97 [#101]: https://github.com/aseemk/json5/pull/101 json5-0.5.0/README.md000066400000000000000000000213101267246057100140400ustar00rootroot00000000000000# JSON5 – Modern JSON [![Build Status](https://travis-ci.org/aseemk/json5.png)](https://travis-ci.org/aseemk/json5) JSON is an excellent data format, but we think it can be better. **JSON5 is a proposed extension to JSON** that aims to make it easier for *humans to write and maintain* by hand. It does this by adding some minimal syntax features directly from ECMAScript 5. JSON5 remains a **strict subset of JavaScript**, adds **no new data types**, and **works with all existing JSON content**. JSON5 is *not* an official successor to JSON, and JSON5 content may *not* work with existing JSON parsers. For this reason, JSON5 files use a new .json5 extension. *(TODO: new MIME type needed too.)* The code here is a **reference JavaScript implementation** for both Node.js and all browsers. It’s based directly off of Douglas Crockford’s own [JSON implementation][json_parse.js], and it’s both robust and secure. ## Why JSON isn’t the friendliest to *write*. Keys need to be quoted, objects and arrays can’t have trailing commas, and comments aren’t allowed — even though none of these are the case with regular JavaScript today. That was fine when JSON’s goal was to be a great data format, but JSON’s usage has expanded beyond *machines*. JSON is now used for writing [configs][ex1], [manifests][ex2], even [tests][ex3] — all by *humans*. [ex1]: http://plovr.com/docs.html [ex2]: https://www.npmjs.org/doc/files/package.json.html [ex3]: http://code.google.com/p/fuzztester/wiki/JSONFileFormat There are other formats that are human-friendlier, like YAML, but changing from JSON to a completely different format is undesirable in many cases. JSON5’s aim is to remain close to JSON and JavaScript. ## Features The following is the exact list of additions to JSON’s syntax introduced by JSON5. **All of these are optional**, and **all of these come from ES5**. ### Objects - Object keys can be unquoted if they’re valid [identifiers][mdn_variables]. Yes, even reserved keywords (like `default`) are valid unquoted keys in ES5 [[§11.1.5](http://es5.github.com/#x11.1.5), [§7.6](http://es5.github.com/#x7.6)]. ([More info](https://mathiasbynens.be/notes/javascript-identifiers)) *(TODO: Unicode characters and escape sequences aren’t yet supported in this implementation.)* - Objects can have trailing commas. [mdn_variables]: https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Core_Language_Features#Variables ### Arrays - Arrays can have trailing commas. ### Strings - Strings can be single-quoted. - Strings can be split across multiple lines; just prefix each newline with a backslash. [ES5 [§7.8.4](http://es5.github.com/#x7.8.4)] ### Numbers - Numbers can be hexadecimal (base 16). - Numbers can begin or end with a (leading or trailing) decimal point. - Numbers can include `Infinity`, `-Infinity`, `NaN`, and `-NaN`. - Numbers can begin with an explicit plus sign. ### Comments - Both inline (single-line) and block (multi-line) comments are allowed. ## Example The following is a contrived example, but it illustrates most of the features: ```js { foo: 'bar', while: true, this: 'is a \ multi-line string', // this is an inline comment here: 'is another', // inline comment /* this is a block comment that continues on another line */ hex: 0xDEADbeef, half: .5, delta: +10, to: Infinity, // and beyond! finally: 'a trailing comma', oh: [ "we shouldn't forget", 'arrays can have', 'trailing commas too', ], } ``` This implementation’s own [package.json5](package.json5) is more realistic: ```js // This file is written in JSON5 syntax, naturally, but npm needs a regular // JSON file, so compile via `npm run build`. Be sure to keep both in sync! { name: 'json5', version: '0.5.0', description: 'JSON for the ES5 era.', keywords: ['json', 'es5'], author: 'Aseem Kishore ', contributors: [ // TODO: Should we remove this section in favor of GitHub's list? // https://github.com/aseemk/json5/contributors 'Max Nanasy ', 'Andrew Eisenberg ', 'Jordan Tucker ', ], main: 'lib/json5.js', bin: 'lib/cli.js', files: ["lib/"], dependencies: {}, devDependencies: { gulp: "^3.9.1", 'gulp-jshint': "^2.0.0", jshint: "^2.9.1", 'jshint-stylish': "^2.1.0", mocha: "^2.4.5" }, scripts: { build: 'node ./lib/cli.js -c package.json5', test: 'mocha --ui exports --reporter spec', // TODO: Would it be better to define these in a mocha.opts file? }, homepage: 'http://json5.org/', license: 'MIT', repository: { type: 'git', url: 'https://github.com/aseemk/json5.git', }, } ``` ## Community Join the [Google Group](http://groups.google.com/group/json5) if you’re interested in JSON5 news, updates, and general discussion. Don’t worry, it’s very low-traffic. The [GitHub wiki](https://github.com/aseemk/json5/wiki) is a good place to track JSON5 support and usage. Contribute freely there! [GitHub Issues](https://github.com/aseemk/json5/issues) is the place to formally propose feature requests and report bugs. Questions and general feedback are better directed at the Google Group. ## Usage This JavaScript implementation of JSON5 simply provides a `JSON5` object just like the native ES5 `JSON` object. To use from Node: ```sh npm install json5 ``` ```js var JSON5 = require('json5'); ``` To use in the browser (adds the `JSON5` object to the global namespace): ```html ``` Then in both cases, you can simply replace native `JSON` calls with `JSON5`: ```js var obj = JSON5.parse('{unquoted:"key",trailing:"comma",}'); var str = JSON5.stringify(obj); ``` `JSON5.parse` supports all of the JSON5 features listed above (*TODO: except Unicode*), as well as the native [`reviver` argument][json-parse]. [json-parse]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse `JSON5.stringify` mainly avoids quoting keys where possible, but we hope to keep expanding it in the future (e.g. to also output trailing commas). It supports the native [`replacer` and `space` arguments][json-stringify], as well. *(TODO: Any implemented `toJSON` methods aren’t used today.)* [json-stringify]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify ### Extras If you’re running this on Node, you can also register a JSON5 `require()` hook to let you `require()` `.json5` files just like you can `.json` files: ```js require('json5/lib/require'); require('./path/to/foo'); // tries foo.json5 after foo.js, foo.json, etc. require('./path/to/bar.json5'); ``` This module also provides a `json5` executable (requires Node) for converting JSON5 files to JSON: ```sh json5 -c path/to/foo.json5 # generates path/to/foo.json ``` ## Development ```sh git clone git://github.com/aseemk/json5.git cd json5 npm install npm test ``` As the `package.json5` file states, be sure to run `npm run build` on changes to `package.json5`, since npm requires `package.json`. Feel free to [file issues](https://github.com/aseemk/json5/issues) and submit [pull requests](https://github.com/aseemk/json5/pulls) — contributions are welcome. If you do submit a pull request, please be sure to add or update the tests, and ensure that `npm test` continues to pass. ## License MIT License © 2012-2016 Aseem Kishore, and [others]( https://github.com/aseemk/json5/contributors). ## Credits [Michael Bolin](http://bolinfest.com/) independently arrived at and published some of these same ideas with awesome explanations and detail. Recommended reading: [Suggested Improvements to JSON](http://bolinfest.com/essays/json.html) [Douglas Crockford](http://www.crockford.com/) of course designed and built JSON, but his state machine diagrams on the [JSON website](http://json.org/), as cheesy as it may sound, gave me motivation and confidence that building a new parser to implement these ideas this was within my reach! This code is also modeled directly off of Doug’s open-source [json_parse.js][] parser. I’m super grateful for that clean and well-documented code. [json_parse.js]: https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js [Max Nanasy](https://github.com/MaxNanasy) has been an early and prolific supporter, contributing multiple patches and ideas. Thanks Max! [Andrew Eisenberg](https://github.com/aeisenberg) has contributed the `stringify` method. [Jordan Tucker](https://github.com/jordanbtucker) has aligned JSON5 more closely with ES5 and is actively maintaining this project. json5-0.5.0/gulpfile.js000066400000000000000000000003071267246057100147310ustar00rootroot00000000000000var gulp = require('gulp'); var jshint = require('gulp-jshint'); gulp.task('lint', function() { return gulp.src('./lib/*.js') .pipe(jshint()) .pipe(jshint.reporter('jshint-stylish')); }); json5-0.5.0/lib/000077500000000000000000000000001267246057100133325ustar00rootroot00000000000000json5-0.5.0/lib/cli.js000077500000000000000000000022071267246057100144430ustar00rootroot00000000000000#!/usr/bin/env node // cli.js // JSON5 command-line interface. // // This is pretty minimal for now; just supports compiling files via `-c`. // TODO More useful functionality, like output path, watch, etc.? var FS = require('fs'); var JSON5 = require('./json5'); var Path = require('path'); var USAGE = [ 'Usage: json5 -c path/to/file.json5 ...', 'Compiles JSON5 files into sibling JSON files with the same basenames.', ].join('\n'); // if valid, args look like [node, json5, -c, file1, file2, ...] var args = process.argv; if (args.length < 4 || args[2] !== '-c') { console.error(USAGE); process.exit(1); } var cwd = process.cwd(); var files = args.slice(3); // iterate over each file and convert JSON5 files to JSON: files.forEach(function (file) { var path = Path.resolve(cwd, file); var basename = Path.basename(path, '.json5'); var dirname = Path.dirname(path); var json5 = FS.readFileSync(path, 'utf8'); var obj = JSON5.parse(json5); var json = JSON.stringify(obj, null, 4); // 4 spaces; TODO configurable? path = Path.join(dirname, basename + '.json'); FS.writeFileSync(path, json, 'utf8'); }); json5-0.5.0/lib/json5.js000066400000000000000000000577171267246057100147470ustar00rootroot00000000000000// json5.js // Modern JSON. See README.md for details. // // This file is based directly off of Douglas Crockford's json_parse.js: // https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js var JSON5 = (typeof exports === 'object' ? exports : {}); JSON5.parse = (function () { "use strict"; // This is a function that can parse a JSON5 text, producing a JavaScript // data structure. It is a simple, recursive descent parser. It does not use // eval or regular expressions, so it can be used as a model for implementing // a JSON5 parser in other languages. // We are defining the function inside of another function to avoid creating // global variables. var at, // The index of the current character lineNumber, // The current line number columnNumber, // The current column number ch, // The current character escapee = { "'": "'", '"': '"', '\\': '\\', '/': '/', '\n': '', // Replace escaped newlines in strings w/ empty string b: '\b', f: '\f', n: '\n', r: '\r', t: '\t' }, ws = [ ' ', '\t', '\r', '\n', '\v', '\f', '\xA0', '\uFEFF' ], text, renderChar = function (chr) { return chr === '' ? 'EOF' : "'" + chr + "'"; }, error = function (m) { // Call error when something is wrong. var error = new SyntaxError(); // beginning of message suffix to agree with that provided by Gecko - see https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse error.message = m + " at line " + lineNumber + " column " + columnNumber + " of the JSON5 data. Still to read: " + JSON.stringify(text.substring(at - 1, at + 19)); error.at = at; // These two property names have been chosen to agree with the ones in Gecko, the only popular // environment which seems to supply this info on JSON.parse error.lineNumber = lineNumber; error.columnNumber = columnNumber; throw error; }, next = function (c) { // If a c parameter is provided, verify that it matches the current character. if (c && c !== ch) { error("Expected " + renderChar(c) + " instead of " + renderChar(ch)); } // Get the next character. When there are no more characters, // return the empty string. ch = text.charAt(at); at++; columnNumber++; if (ch === '\n' || ch === '\r' && peek() !== '\n') { lineNumber++; columnNumber = 0; } return ch; }, peek = function () { // Get the next character without consuming it or // assigning it to the ch varaible. return text.charAt(at); }, identifier = function () { // Parse an identifier. Normally, reserved words are disallowed here, but we // only use this for unquoted object keys, where reserved words are allowed, // so we don't check for those here. References: // - http://es5.github.com/#x7.6 // - https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Core_Language_Features#Variables // - http://docstore.mik.ua/orelly/webprog/jscript/ch02_07.htm // TODO Identifiers can have Unicode "letters" in them; add support for those. var key = ch; // Identifiers must start with a letter, _ or $. if ((ch !== '_' && ch !== '$') && (ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z')) { error("Bad identifier as unquoted key"); } // Subsequent characters can contain digits. while (next() && ( ch === '_' || ch === '$' || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9'))) { key += ch; } return key; }, number = function () { // Parse a number value. var number, sign = '', string = '', base = 10; if (ch === '-' || ch === '+') { sign = ch; next(ch); } // support for Infinity (could tweak to allow other words): if (ch === 'I') { number = word(); if (typeof number !== 'number' || isNaN(number)) { error('Unexpected word for number'); } return (sign === '-') ? -number : number; } // support for NaN if (ch === 'N' ) { number = word(); if (!isNaN(number)) { error('expected word to be NaN'); } // ignore sign as -NaN also is NaN return number; } if (ch === '0') { string += ch; next(); if (ch === 'x' || ch === 'X') { string += ch; next(); base = 16; } else if (ch >= '0' && ch <= '9') { error('Octal literal'); } } switch (base) { case 10: while (ch >= '0' && ch <= '9' ) { string += ch; next(); } if (ch === '.') { string += '.'; while (next() && ch >= '0' && ch <= '9') { string += ch; } } if (ch === 'e' || ch === 'E') { string += ch; next(); if (ch === '-' || ch === '+') { string += ch; next(); } while (ch >= '0' && ch <= '9') { string += ch; next(); } } break; case 16: while (ch >= '0' && ch <= '9' || ch >= 'A' && ch <= 'F' || ch >= 'a' && ch <= 'f') { string += ch; next(); } break; } if(sign === '-') { number = -string; } else { number = +string; } if (!isFinite(number)) { error("Bad number"); } else { return number; } }, string = function () { // Parse a string value. var hex, i, string = '', delim, // double quote or single quote uffff; // When parsing for string values, we must look for ' or " and \ characters. if (ch === '"' || ch === "'") { delim = ch; while (next()) { if (ch === delim) { next(); return string; } else if (ch === '\\') { next(); if (ch === 'u') { uffff = 0; for (i = 0; i < 4; i += 1) { hex = parseInt(next(), 16); if (!isFinite(hex)) { break; } uffff = uffff * 16 + hex; } string += String.fromCharCode(uffff); } else if (ch === '\r') { if (peek() === '\n') { next(); } } else if (typeof escapee[ch] === 'string') { string += escapee[ch]; } else { break; } } else if (ch === '\n') { // unescaped newlines are invalid; see: // https://github.com/aseemk/json5/issues/24 // TODO this feels special-cased; are there other // invalid unescaped chars? break; } else { string += ch; } } } error("Bad string"); }, inlineComment = function () { // Skip an inline comment, assuming this is one. The current character should // be the second / character in the // pair that begins this inline comment. // To finish the inline comment, we look for a newline or the end of the text. if (ch !== '/') { error("Not an inline comment"); } do { next(); if (ch === '\n' || ch === '\r') { next(); return; } } while (ch); }, blockComment = function () { // Skip a block comment, assuming this is one. The current character should be // the * character in the /* pair that begins this block comment. // To finish the block comment, we look for an ending */ pair of characters, // but we also watch for the end of text before the comment is terminated. if (ch !== '*') { error("Not a block comment"); } do { next(); while (ch === '*') { next('*'); if (ch === '/') { next('/'); return; } } } while (ch); error("Unterminated block comment"); }, comment = function () { // Skip a comment, whether inline or block-level, assuming this is one. // Comments always begin with a / character. if (ch !== '/') { error("Not a comment"); } next('/'); if (ch === '/') { inlineComment(); } else if (ch === '*') { blockComment(); } else { error("Unrecognized comment"); } }, white = function () { // Skip whitespace and comments. // Note that we're detecting comments by only a single / character. // This works since regular expressions are not valid JSON(5), but this will // break if there are other valid values that begin with a / character! while (ch) { if (ch === '/') { comment(); } else if (ws.indexOf(ch) >= 0) { next(); } else { return; } } }, word = function () { // true, false, or null. switch (ch) { case 't': next('t'); next('r'); next('u'); next('e'); return true; case 'f': next('f'); next('a'); next('l'); next('s'); next('e'); return false; case 'n': next('n'); next('u'); next('l'); next('l'); return null; case 'I': next('I'); next('n'); next('f'); next('i'); next('n'); next('i'); next('t'); next('y'); return Infinity; case 'N': next( 'N' ); next( 'a' ); next( 'N' ); return NaN; } error("Unexpected " + renderChar(ch)); }, value, // Place holder for the value function. array = function () { // Parse an array value. var array = []; if (ch === '[') { next('['); white(); while (ch) { if (ch === ']') { next(']'); return array; // Potentially empty array } // ES5 allows omitting elements in arrays, e.g. [,] and // [,null]. We don't allow this in JSON5. if (ch === ',') { error("Missing array element"); } else { array.push(value()); } white(); // If there's no comma after this value, this needs to // be the end of the array. if (ch !== ',') { next(']'); return array; } next(','); white(); } } error("Bad array"); }, object = function () { // Parse an object value. var key, object = {}; if (ch === '{') { next('{'); white(); while (ch) { if (ch === '}') { next('}'); return object; // Potentially empty object } // Keys can be unquoted. If they are, they need to be // valid JS identifiers. if (ch === '"' || ch === "'") { key = string(); } else { key = identifier(); } white(); next(':'); object[key] = value(); white(); // If there's no comma after this pair, this needs to be // the end of the object. if (ch !== ',') { next('}'); return object; } next(','); white(); } } error("Bad object"); }; value = function () { // Parse a JSON value. It could be an object, an array, a string, a number, // or a word. white(); switch (ch) { case '{': return object(); case '[': return array(); case '"': case "'": return string(); case '-': case '+': case '.': return number(); default: return ch >= '0' && ch <= '9' ? number() : word(); } }; // Return the json_parse function. It will have access to all of the above // functions and variables. return function (source, reviver) { var result; text = String(source); at = 0; lineNumber = 1; columnNumber = 1; ch = ' '; result = value(); white(); if (ch) { error("Syntax error"); } // If there is a reviver function, we recursively walk the new structure, // passing each name/value pair to the reviver function for possible // transformation, starting with a temporary root object that holds the result // in an empty key. If there is not a reviver function, we simply return the // result. return typeof reviver === 'function' ? (function walk(holder, key) { var k, v, value = holder[key]; if (value && typeof value === 'object') { for (k in value) { if (Object.prototype.hasOwnProperty.call(value, k)) { v = walk(value, k); if (v !== undefined) { value[k] = v; } else { delete value[k]; } } } } return reviver.call(holder, key, value); }({'': result}, '')) : result; }; }()); // JSON5 stringify will not quote keys where appropriate JSON5.stringify = function (obj, replacer, space) { if (replacer && (typeof(replacer) !== "function" && !isArray(replacer))) { throw new Error('Replacer must be a function or an array'); } var getReplacedValueOrUndefined = function(holder, key, isTopLevel) { var value = holder[key]; // Replace the value with its toJSON value first, if possible if (value && value.toJSON && typeof value.toJSON === "function") { value = value.toJSON(); } // If the user-supplied replacer if a function, call it. If it's an array, check objects' string keys for // presence in the array (removing the key/value pair from the resulting JSON if the key is missing). if (typeof(replacer) === "function") { return replacer.call(holder, key, value); } else if(replacer) { if (isTopLevel || isArray(holder) || replacer.indexOf(key) >= 0) { return value; } else { return undefined; } } else { return value; } }; function isWordChar(c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '_' || c === '$'; } function isWordStart(c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_' || c === '$'; } function isWord(key) { if (typeof key !== 'string') { return false; } if (!isWordStart(key[0])) { return false; } var i = 1, length = key.length; while (i < length) { if (!isWordChar(key[i])) { return false; } i++; } return true; } // export for use in tests JSON5.isWord = isWord; // polyfills function isArray(obj) { if (Array.isArray) { return Array.isArray(obj); } else { return Object.prototype.toString.call(obj) === '[object Array]'; } } function isDate(obj) { return Object.prototype.toString.call(obj) === '[object Date]'; } var objStack = []; function checkForCircular(obj) { for (var i = 0; i < objStack.length; i++) { if (objStack[i] === obj) { throw new TypeError("Converting circular structure to JSON"); } } } function makeIndent(str, num, noNewLine) { if (!str) { return ""; } // indentation no more than 10 chars if (str.length > 10) { str = str.substring(0, 10); } var indent = noNewLine ? "" : "\n"; for (var i = 0; i < num; i++) { indent += str; } return indent; } var indentStr; if (space) { if (typeof space === "string") { indentStr = space; } else if (typeof space === "number" && space >= 0) { indentStr = makeIndent(" ", space, true); } else { // ignore space parameter } } // Copied from Crokford's implementation of JSON // See https://github.com/douglascrockford/JSON-js/blob/e39db4b7e6249f04a195e7dd0840e610cc9e941e/json2.js#L195 // Begin var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, meta = { // table of character substitutions '\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"' : '\\"', '\\': '\\\\' }; function escapeString(string) { // If the string contains no control characters, no quote characters, and no // backslash characters, then we can safely slap some quotes around it. // Otherwise we must also replace the offending characters with safe escape // sequences. escapable.lastIndex = 0; return escapable.test(string) ? '"' + string.replace(escapable, function (a) { var c = meta[a]; return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); }) + '"' : '"' + string + '"'; } // End function internalStringify(holder, key, isTopLevel) { var buffer, res; // Replace the value, if necessary var obj_part = getReplacedValueOrUndefined(holder, key, isTopLevel); if (obj_part && !isDate(obj_part)) { // unbox objects // don't unbox dates, since will turn it into number obj_part = obj_part.valueOf(); } switch(typeof obj_part) { case "boolean": return obj_part.toString(); case "number": if (isNaN(obj_part) || !isFinite(obj_part)) { return "null"; } return obj_part.toString(); case "string": return escapeString(obj_part.toString()); case "object": if (obj_part === null) { return "null"; } else if (isArray(obj_part)) { checkForCircular(obj_part); buffer = "["; objStack.push(obj_part); for (var i = 0; i < obj_part.length; i++) { res = internalStringify(obj_part, i, false); buffer += makeIndent(indentStr, objStack.length); if (res === null || typeof res === "undefined") { buffer += "null"; } else { buffer += res; } if (i < obj_part.length-1) { buffer += ","; } else if (indentStr) { buffer += "\n"; } } objStack.pop(); buffer += makeIndent(indentStr, objStack.length, true) + "]"; } else { checkForCircular(obj_part); buffer = "{"; var nonEmpty = false; objStack.push(obj_part); for (var prop in obj_part) { if (obj_part.hasOwnProperty(prop)) { var value = internalStringify(obj_part, prop, false); isTopLevel = false; if (typeof value !== "undefined" && value !== null) { buffer += makeIndent(indentStr, objStack.length); nonEmpty = true; key = isWord(prop) ? prop : escapeString(prop); buffer += key + ":" + (indentStr ? ' ' : '') + value + ","; } } } objStack.pop(); if (nonEmpty) { buffer = buffer.substring(0, buffer.length-1) + makeIndent(indentStr, objStack.length) + "}"; } else { buffer = '{}'; } } return buffer; default: // functions and undefined should be ignored return undefined; } } // special case...when undefined is used inside of // a compound object/array, return null. // but when top-level, return undefined var topLevelHolder = {"":obj}; if (obj === undefined) { return getReplacedValueOrUndefined(topLevelHolder, '', true); } return internalStringify(topLevelHolder, '', true); }; json5-0.5.0/lib/require.js000066400000000000000000000011341267246057100153430ustar00rootroot00000000000000// require.js // Node.js only: adds a require() hook for .json5 files, just like the native // hook for .json files. // // Usage: // require('json5/require'); // require('./foo'); // will check foo.json5 after foo.js, foo.json, etc. // require('./bar.json5'); var FS = require('fs'); var JSON5 = require('./json5'); // Modeled off of (v0.6.18 link; check latest too): // https://github.com/joyent/node/blob/v0.6.18/lib/module.js#L468-L472 require.extensions['.json5'] = function (module, filename) { var content = FS.readFileSync(filename, 'utf8'); module.exports = JSON5.parse(content); }; json5-0.5.0/package.json000066400000000000000000000017061267246057100150560ustar00rootroot00000000000000{ "name": "json5", "version": "0.5.0", "description": "JSON for the ES5 era.", "keywords": [ "json", "es5" ], "author": "Aseem Kishore ", "contributors": [ "Max Nanasy ", "Andrew Eisenberg ", "Jordan Tucker " ], "main": "lib/json5.js", "bin": "lib/cli.js", "files": [ "lib/" ], "dependencies": {}, "devDependencies": { "gulp": "^3.9.1", "gulp-jshint": "^2.0.0", "jshint": "^2.9.1", "jshint-stylish": "^2.1.0", "mocha": "^2.4.5" }, "scripts": { "build": "node ./lib/cli.js -c package.json5", "test": "mocha --ui exports --reporter spec" }, "homepage": "http://json5.org/", "license": "MIT", "repository": { "type": "git", "url": "https://github.com/aseemk/json5.git" } }json5-0.5.0/package.json5000066400000000000000000000023441267246057100151420ustar00rootroot00000000000000// This file is written in JSON5 syntax, naturally, but npm needs a regular // JSON file, so compile via `npm run build`. Be sure to keep both in sync! { name: 'json5', version: '0.5.0', description: 'JSON for the ES5 era.', keywords: ['json', 'es5'], author: 'Aseem Kishore ', contributors: [ // TODO: Should we remove this section in favor of GitHub's list? // https://github.com/aseemk/json5/contributors 'Max Nanasy ', 'Andrew Eisenberg ', 'Jordan Tucker ', ], main: 'lib/json5.js', bin: 'lib/cli.js', files: ["lib/"], dependencies: {}, devDependencies: { gulp: "^3.9.1", 'gulp-jshint': "^2.0.0", jshint: "^2.9.1", 'jshint-stylish': "^2.1.0", mocha: "^2.4.5" }, scripts: { build: 'node ./lib/cli.js -c package.json5', test: 'mocha --ui exports --reporter spec', // TODO: Would it be better to define these in a mocha.opts file? }, homepage: 'http://json5.org/', license: 'MIT', repository: { type: 'git', url: 'https://github.com/aseemk/json5.git', }, } json5-0.5.0/test/000077500000000000000000000000001267246057100135435ustar00rootroot00000000000000json5-0.5.0/test/count-newlines.js000066400000000000000000000016411267246057100170550ustar00rootroot00000000000000// count-newlines.js // Tests JSON5's line counting algorithm's support for the basic varieties of newline that we support - // LF, CR+LF and CR "use strict"; var assert = require('assert'); var JSON5 = require('..'); // Each of these cases should give rise to a parse error with the same coordinates var cases = { LF: "{\u000a 10thing", CRLF: "{\u000d\u000a 10thing", CR: "{\u000d 10thing" }; var spec = { lineNumber: 2, columnNumber: 5 }; exports['count-newlines'] = {}; Object.keys(cases).forEach(function (key) { var str = cases[key]; exports['count-newlines'][key] = function () { var err; try { JSON5.parse(str); } catch (e) { err = e; } assert(err, 'Expected JSON5 parsing to fail.'); assert.equal(err.lineNumber, spec.lineNumber); assert.equal(err.columnNumber, spec.columnNumber); }; }); json5-0.5.0/test/parse-cases/000077500000000000000000000000001267246057100157515ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/arrays/000077500000000000000000000000001267246057100172525ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/arrays/empty-array.json000066400000000000000000000000021267246057100224070ustar00rootroot00000000000000[]json5-0.5.0/test/parse-cases/arrays/leading-comma-array.js000066400000000000000000000000151267246057100234150ustar00rootroot00000000000000[ ,null ]json5-0.5.0/test/parse-cases/arrays/lone-trailing-comma-array.js000066400000000000000000000000111267246057100245520ustar00rootroot00000000000000[ , ]json5-0.5.0/test/parse-cases/arrays/no-comma-array.errorSpec000066400000000000000000000001421267246057100237570ustar00rootroot00000000000000{ at: 16, lineNumber: 3, columnNumber: 5, message: "Expected ']' instead of 'f'" }json5-0.5.0/test/parse-cases/arrays/no-comma-array.txt000066400000000000000000000000261267246057100226330ustar00rootroot00000000000000[ true false ]json5-0.5.0/test/parse-cases/arrays/regular-array.json000066400000000000000000000000411267246057100227150ustar00rootroot00000000000000[ true, false, null ]json5-0.5.0/test/parse-cases/arrays/trailing-comma-array.json5000066400000000000000000000000151267246057100242450ustar00rootroot00000000000000[ null, ]json5-0.5.0/test/parse-cases/comments/000077500000000000000000000000001267246057100175765ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/comments/block-comment-following-array-element.json5000066400000000000000000000000501267246057100300440ustar00rootroot00000000000000[ false /* true */ ]json5-0.5.0/test/parse-cases/comments/block-comment-following-top-level-value.json5000066400000000000000000000001211267246057100303170ustar00rootroot00000000000000null /* Some non-comment top-level value is needed; we use null above. */json5-0.5.0/test/parse-cases/comments/block-comment-in-string.json000066400000000000000000000000701267246057100251300ustar00rootroot00000000000000"This /* block comment */ isn't really a block comment."json5-0.5.0/test/parse-cases/comments/block-comment-preceding-top-level-value.json5000066400000000000000000000001211267246057100302570ustar00rootroot00000000000000/* Some non-comment top-level value is needed; we use null below. */ nulljson5-0.5.0/test/parse-cases/comments/block-comment-with-asterisks.json5000066400000000000000000000002371267246057100262710ustar00rootroot00000000000000/** * This is a JavaDoc-like block comment. * It contains asterisks inside of it. * It might also be closed with multiple asterisks. * Like this: **/ truejson5-0.5.0/test/parse-cases/comments/inline-comment-following-array-element.json5000066400000000000000000000000271267246057100302340ustar00rootroot00000000000000[ false // true ]json5-0.5.0/test/parse-cases/comments/inline-comment-following-top-level-value.json5000066400000000000000000000001051267246057100305050ustar00rootroot00000000000000null // Some non-comment top-level value is needed; we use null here.json5-0.5.0/test/parse-cases/comments/inline-comment-in-string.json000066400000000000000000000000701267246057100253140ustar00rootroot00000000000000"This inline comment // isn't really an inline comment."json5-0.5.0/test/parse-cases/comments/inline-comment-preceding-top-level-value.json5000066400000000000000000000001061267246057100304460ustar00rootroot00000000000000// Some non-comment top-level value is needed; we use null below. nulljson5-0.5.0/test/parse-cases/comments/top-level-block-comment.errorSpec000066400000000000000000000001251267246057100261210ustar00rootroot00000000000000{ at: 77, lineNumber: 4, columnNumber: 3, message: "Unexpected EOF" }json5-0.5.0/test/parse-cases/comments/top-level-block-comment.txt000066400000000000000000000001141267246057100247720ustar00rootroot00000000000000/* This should fail; comments cannot be the only top-level value. */json5-0.5.0/test/parse-cases/comments/top-level-inline-comment.errorSpec000066400000000000000000000001261267246057100263060ustar00rootroot00000000000000{ at: 66, lineNumber: 1, columnNumber: 67, message: "Unexpected EOF" }json5-0.5.0/test/parse-cases/comments/top-level-inline-comment.txt000066400000000000000000000001011267246057100251520ustar00rootroot00000000000000// This should fail; comments cannot be the only top-level value.json5-0.5.0/test/parse-cases/comments/unterminated-block-comment.txt000066400000000000000000000002101267246057100255570ustar00rootroot00000000000000true /* This block comment doesn't terminate. There was a legitimate value before this, but this is still invalid JS/JSON5. json5-0.5.0/test/parse-cases/misc/000077500000000000000000000000001267246057100167045ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/misc/empty.txt000066400000000000000000000000001267246057100205710ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/misc/npm-package.json000066400000000000000000000042131267246057100217620ustar00rootroot00000000000000{ "name": "npm", "publishConfig": { "proprietary-attribs": false }, "description": "A package manager for node", "keywords": [ "package manager", "modules", "install", "package.json" ], "version": "1.1.22", "preferGlobal": true, "config": { "publishtest": false }, "homepage": "http://npmjs.org/", "author": "Isaac Z. Schlueter (http://blog.izs.me)", "repository": { "type": "git", "url": "https://github.com/isaacs/npm" }, "bugs": { "email": "npm-@googlegroups.com", "url": "http://github.com/isaacs/npm/issues" }, "directories": { "doc": "./doc", "man": "./man", "lib": "./lib", "bin": "./bin" }, "main": "./lib/npm.js", "bin": "./bin/npm-cli.js", "dependencies": { "semver": "~1.0.14", "ini": "1", "slide": "1", "abbrev": "1", "graceful-fs": "~1.1.1", "minimatch": "~0.2", "nopt": "1", "node-uuid": "~1.3", "proto-list": "1", "rimraf": "2", "request": "~2.9", "which": "1", "tar": "~0.1.12", "fstream": "~0.1.17", "block-stream": "*", "inherits": "1", "mkdirp": "0.3", "read": "0", "lru-cache": "1", "node-gyp": "~0.4.1", "fstream-npm": "0 >=0.0.5", "uid-number": "0", "archy": "0", "chownr": "0" }, "bundleDependencies": [ "slide", "ini", "semver", "abbrev", "graceful-fs", "minimatch", "nopt", "node-uuid", "rimraf", "request", "proto-list", "which", "tar", "fstream", "block-stream", "inherits", "mkdirp", "read", "lru-cache", "node-gyp", "fstream-npm", "uid-number", "archy", "chownr" ], "devDependencies": { "ronn": "https://github.com/isaacs/ronnjs/tarball/master" }, "engines": { "node": "0.6 || 0.7 || 0.8", "npm": "1" }, "scripts": { "test": "node ./test/run.js", "prepublish": "npm prune; rm -rf node_modules/*/{test,example,bench}*; make -j4 doc", "dumpconf": "env | grep npm | sort | uniq" }, "licenses": [ { "type": "MIT +no-false-attribs", "url": "http://github.com/isaacs/npm/raw/master/LICENSE" } ] } json5-0.5.0/test/parse-cases/misc/npm-package.json5000066400000000000000000000040571267246057100220550ustar00rootroot00000000000000{ name: 'npm', publishConfig: { 'proprietary-attribs': false, }, description: 'A package manager for node', keywords: [ 'package manager', 'modules', 'install', 'package.json', ], version: '1.1.22', preferGlobal: true, config: { publishtest: false, }, homepage: 'http://npmjs.org/', author: 'Isaac Z. Schlueter (http://blog.izs.me)', repository: { type: 'git', url: 'https://github.com/isaacs/npm', }, bugs: { email: 'npm-@googlegroups.com', url: 'http://github.com/isaacs/npm/issues', }, directories: { doc: './doc', man: './man', lib: './lib', bin: './bin', }, main: './lib/npm.js', bin: './bin/npm-cli.js', dependencies: { semver: '~1.0.14', ini: '1', slide: '1', abbrev: '1', 'graceful-fs': '~1.1.1', minimatch: '~0.2', nopt: '1', 'node-uuid': '~1.3', 'proto-list': '1', rimraf: '2', request: '~2.9', which: '1', tar: '~0.1.12', fstream: '~0.1.17', 'block-stream': '*', inherits: '1', mkdirp: '0.3', read: '0', 'lru-cache': '1', 'node-gyp': '~0.4.1', 'fstream-npm': '0 >=0.0.5', 'uid-number': '0', archy: '0', chownr: '0', }, bundleDependencies: [ 'slide', 'ini', 'semver', 'abbrev', 'graceful-fs', 'minimatch', 'nopt', 'node-uuid', 'rimraf', 'request', 'proto-list', 'which', 'tar', 'fstream', 'block-stream', 'inherits', 'mkdirp', 'read', 'lru-cache', 'node-gyp', 'fstream-npm', 'uid-number', 'archy', 'chownr', ], devDependencies: { ronn: 'https://github.com/isaacs/ronnjs/tarball/master', }, engines: { node: '0.6 || 0.7 || 0.8', npm: '1', }, scripts: { test: 'node ./test/run.js', prepublish: 'npm prune; rm -rf node_modules/*/{test,example,bench}*; make -j4 doc', dumpconf: 'env | grep npm | sort | uniq', }, licenses: [ { type: 'MIT +no-false-attribs', url: 'http://github.com/isaacs/npm/raw/master/LICENSE', }, ], } json5-0.5.0/test/parse-cases/misc/readme-example.json5000066400000000000000000000007041267246057100225530ustar00rootroot00000000000000{ foo: 'bar', while: true, this: 'is a \ multi-line string', // this is an inline comment here: 'is another', // inline comment /* this is a block comment that continues on another line */ hex: 0xDEADbeef, half: .5, delta: +10, to: Infinity, // and beyond! finally: 'a trailing comma', oh: [ "we shouldn't forget", 'arrays can have', 'trailing commas too', ], } json5-0.5.0/test/parse-cases/misc/valid-whitespace.json5000066400000000000000000000002101267246057100231060ustar00rootroot00000000000000{ // An invalid form feed character (\x0c) has been entered before this comment. // Be careful not to delete it. "a": true } json5-0.5.0/test/parse-cases/new-lines/000077500000000000000000000000001267246057100176525ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/new-lines/.editorconfig000066400000000000000000000004371267246057100223330ustar00rootroot00000000000000# Since we're testing different representations of new lines, # make sure the editor doesn't mangle line endings. # Don't commit files in this directory unless you've checked # their escaped new lines. [*-lf.*] end_of_line = lf [*-cr.*] end_of_line = cr [*-crlf.*] end_of_line = crlf json5-0.5.0/test/parse-cases/new-lines/.gitattributes000066400000000000000000000001721267246057100225450ustar00rootroot00000000000000# Since we're testing different representations of new lines, # treat all tests in this folder as binary files. * binary json5-0.5.0/test/parse-cases/new-lines/comment-cr.json5000066400000000000000000000000611267246057100226730ustar00rootroot00000000000000{ // This comment is terminated with `\r`. } json5-0.5.0/test/parse-cases/new-lines/comment-crlf.json5000066400000000000000000000000661267246057100232220ustar00rootroot00000000000000{ // This comment is terminated with `\r\n`. } json5-0.5.0/test/parse-cases/new-lines/comment-lf.json5000066400000000000000000000000611267246057100226700ustar00rootroot00000000000000{ // This comment is terminated with `\n`. } json5-0.5.0/test/parse-cases/new-lines/escaped-cr.json5000066400000000000000000000001221267246057100226330ustar00rootroot00000000000000{ // the following string contains an escaped `\r` a: 'line 1 \ line 2' } json5-0.5.0/test/parse-cases/new-lines/escaped-crlf.json5000066400000000000000000000001311267246057100231550ustar00rootroot00000000000000{ // the following string contains an escaped `\r\n` a: 'line 1 \ line 2' } json5-0.5.0/test/parse-cases/new-lines/escaped-lf.json5000066400000000000000000000001221267246057100226300ustar00rootroot00000000000000{ // the following string contains an escaped `\n` a: 'line 1 \ line 2' } json5-0.5.0/test/parse-cases/numbers/000077500000000000000000000000001267246057100174245ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/numbers/float-leading-decimal-point.json5000066400000000000000000000000031267246057100256260ustar00rootroot00000000000000.5 json5-0.5.0/test/parse-cases/numbers/float-leading-zero.json000066400000000000000000000000041267246057100237740ustar00rootroot000000000000000.5 json5-0.5.0/test/parse-cases/numbers/float-trailing-decimal-point-with-integer-exponent.json5000066400000000000000000000000051267246057100323000ustar00rootroot000000000000005.e4 json5-0.5.0/test/parse-cases/numbers/float-trailing-decimal-point.json5000066400000000000000000000000031267246057100260340ustar00rootroot000000000000005. json5-0.5.0/test/parse-cases/numbers/float-with-integer-exponent.json000066400000000000000000000000061267246057100256620ustar00rootroot000000000000001.2e3 json5-0.5.0/test/parse-cases/numbers/float.json000066400000000000000000000000041267246057100214160ustar00rootroot000000000000001.2 json5-0.5.0/test/parse-cases/numbers/hexadecimal-empty.txt000066400000000000000000000000031267246057100235560ustar00rootroot000000000000000x json5-0.5.0/test/parse-cases/numbers/hexadecimal-lowercase-letter.json5000066400000000000000000000000051267246057100261220ustar00rootroot000000000000000xc8 json5-0.5.0/test/parse-cases/numbers/hexadecimal-uppercase-x.json5000066400000000000000000000000051267246057100250750ustar00rootroot000000000000000XC8 json5-0.5.0/test/parse-cases/numbers/hexadecimal-with-integer-exponent.json5000066400000000000000000000000071267246057100271070ustar00rootroot000000000000000xc8e4 json5-0.5.0/test/parse-cases/numbers/hexadecimal.json5000066400000000000000000000000051267246057100226430ustar00rootroot000000000000000xC8 json5-0.5.0/test/parse-cases/numbers/infinity.json5000066400000000000000000000000111267246057100222250ustar00rootroot00000000000000Infinity json5-0.5.0/test/parse-cases/numbers/integer-with-float-exponent.txt000066400000000000000000000000061267246057100255300ustar00rootroot000000000000001e2.3 json5-0.5.0/test/parse-cases/numbers/integer-with-hexadecimal-exponent.txt000066400000000000000000000000061267246057100266670ustar00rootroot000000000000001e0x4 json5-0.5.0/test/parse-cases/numbers/integer-with-integer-exponent.json000066400000000000000000000000051267246057100262110ustar00rootroot000000000000002e23 json5-0.5.0/test/parse-cases/numbers/integer-with-negative-float-exponent.txt000066400000000000000000000000071267246057100273310ustar00rootroot000000000000001e-2.3 json5-0.5.0/test/parse-cases/numbers/integer-with-negative-hexadecimal-exponent.txt000066400000000000000000000000071267246057100304700ustar00rootroot000000000000001e-0x4 json5-0.5.0/test/parse-cases/numbers/integer-with-negative-integer-exponent.json000066400000000000000000000000061267246057100300120ustar00rootroot000000000000002e-23 json5-0.5.0/test/parse-cases/numbers/integer-with-negative-zero-integer-exponent.json000066400000000000000000000000051267246057100307660ustar00rootroot000000000000005e-0 json5-0.5.0/test/parse-cases/numbers/integer-with-positive-float-exponent.txt000066400000000000000000000000071267246057100273710ustar00rootroot000000000000001e+2.3 json5-0.5.0/test/parse-cases/numbers/integer-with-positive-hexadecimal-exponent.txt000066400000000000000000000000071267246057100305300ustar00rootroot000000000000001e+0x4 json5-0.5.0/test/parse-cases/numbers/integer-with-positive-integer-exponent.json000066400000000000000000000000051267246057100300510ustar00rootroot000000000000001e+2 json5-0.5.0/test/parse-cases/numbers/integer-with-positive-zero-integer-exponent.json000066400000000000000000000000051267246057100310260ustar00rootroot000000000000005e+0 json5-0.5.0/test/parse-cases/numbers/integer-with-zero-integer-exponent.json000066400000000000000000000000041267246057100271650ustar00rootroot000000000000005e0 json5-0.5.0/test/parse-cases/numbers/integer.json000066400000000000000000000000031267246057100217450ustar00rootroot0000000000000015 json5-0.5.0/test/parse-cases/numbers/lone-decimal-point.txt000066400000000000000000000000021267246057100236350ustar00rootroot00000000000000. json5-0.5.0/test/parse-cases/numbers/nan.json5000066400000000000000000000000041267246057100211520ustar00rootroot00000000000000NaN json5-0.5.0/test/parse-cases/numbers/negative-float-leading-decimal-point.json5000066400000000000000000000000041267246057100274270ustar00rootroot00000000000000-.5 json5-0.5.0/test/parse-cases/numbers/negative-float-leading-zero.json000066400000000000000000000000051267246057100255750ustar00rootroot00000000000000-0.5 json5-0.5.0/test/parse-cases/numbers/negative-float-trailing-decimal-point.json5000066400000000000000000000000041267246057100276350ustar00rootroot00000000000000-5. json5-0.5.0/test/parse-cases/numbers/negative-float.json000066400000000000000000000000051267246057100232170ustar00rootroot00000000000000-1.2 json5-0.5.0/test/parse-cases/numbers/negative-hexadecimal.json5000066400000000000000000000000061267246057100244440ustar00rootroot00000000000000-0xC8 json5-0.5.0/test/parse-cases/numbers/negative-infinity.json5000066400000000000000000000000121267246057100240260ustar00rootroot00000000000000-Infinity json5-0.5.0/test/parse-cases/numbers/negative-integer.json000066400000000000000000000000041267246057100235460ustar00rootroot00000000000000-15 json5-0.5.0/test/parse-cases/numbers/negative-noctal.js000066400000000000000000000000051267246057100230350ustar00rootroot00000000000000-098 json5-0.5.0/test/parse-cases/numbers/negative-octal.txt000066400000000000000000000000061267246057100230630ustar00rootroot00000000000000-0123 json5-0.5.0/test/parse-cases/numbers/negative-zero-float-leading-decimal-point.json5000066400000000000000000000000041267246057100304040ustar00rootroot00000000000000-.0 json5-0.5.0/test/parse-cases/numbers/negative-zero-float-trailing-decimal-point.json5000066400000000000000000000000041267246057100306120ustar00rootroot00000000000000-0. json5-0.5.0/test/parse-cases/numbers/negative-zero-float.json000066400000000000000000000000051267246057100241740ustar00rootroot00000000000000-0.0 json5-0.5.0/test/parse-cases/numbers/negative-zero-hexadecimal.json5000066400000000000000000000000051267246057100254200ustar00rootroot00000000000000-0x0 json5-0.5.0/test/parse-cases/numbers/negative-zero-integer.json000066400000000000000000000000031267246057100245220ustar00rootroot00000000000000-0 json5-0.5.0/test/parse-cases/numbers/negative-zero-octal.txt000066400000000000000000000000041267246057100240360ustar00rootroot00000000000000-00 json5-0.5.0/test/parse-cases/numbers/noctal-with-leading-octal-digit.js000066400000000000000000000000051267246057100260050ustar00rootroot000000000000000780 json5-0.5.0/test/parse-cases/numbers/noctal.js000066400000000000000000000000041267246057100212340ustar00rootroot00000000000000080 json5-0.5.0/test/parse-cases/numbers/octal.txt000066400000000000000000000000041267246057100212610ustar00rootroot00000000000000010 json5-0.5.0/test/parse-cases/numbers/positive-float-leading-decimal-point.json5000066400000000000000000000000041267246057100274670ustar00rootroot00000000000000+.5 json5-0.5.0/test/parse-cases/numbers/positive-float-leading-zero.json5000066400000000000000000000000051267246057100257220ustar00rootroot00000000000000+0.5 json5-0.5.0/test/parse-cases/numbers/positive-float-trailing-decimal-point.json5000066400000000000000000000000041267246057100276750ustar00rootroot00000000000000+5. json5-0.5.0/test/parse-cases/numbers/positive-float.json5000066400000000000000000000000051267246057100233440ustar00rootroot00000000000000+1.2 json5-0.5.0/test/parse-cases/numbers/positive-hexadecimal.json5000066400000000000000000000000061267246057100245040ustar00rootroot00000000000000+0xC8 json5-0.5.0/test/parse-cases/numbers/positive-infinity.json5000066400000000000000000000000121267246057100240660ustar00rootroot00000000000000+Infinity json5-0.5.0/test/parse-cases/numbers/positive-integer.json5000066400000000000000000000000041267246057100236730ustar00rootroot00000000000000+15 json5-0.5.0/test/parse-cases/numbers/positive-noctal.js000066400000000000000000000000051267246057100230750ustar00rootroot00000000000000+098 json5-0.5.0/test/parse-cases/numbers/positive-octal.txt000066400000000000000000000000061267246057100231230ustar00rootroot00000000000000+0123 json5-0.5.0/test/parse-cases/numbers/positive-zero-float-leading-decimal-point.json5000066400000000000000000000000041267246057100304440ustar00rootroot00000000000000+.0 json5-0.5.0/test/parse-cases/numbers/positive-zero-float-trailing-decimal-point.json5000066400000000000000000000000041267246057100306520ustar00rootroot00000000000000+0. json5-0.5.0/test/parse-cases/numbers/positive-zero-float.json5000066400000000000000000000000051267246057100243210ustar00rootroot00000000000000+0.0 json5-0.5.0/test/parse-cases/numbers/positive-zero-hexadecimal.json5000066400000000000000000000000051267246057100254600ustar00rootroot00000000000000+0x0 json5-0.5.0/test/parse-cases/numbers/positive-zero-integer.json5000066400000000000000000000000031267246057100246470ustar00rootroot00000000000000+0 json5-0.5.0/test/parse-cases/numbers/positive-zero-octal.txt000066400000000000000000000000041267246057100240760ustar00rootroot00000000000000+00 json5-0.5.0/test/parse-cases/numbers/zero-float-leading-decimal-point.json5000066400000000000000000000000031267246057100266030ustar00rootroot00000000000000.0 json5-0.5.0/test/parse-cases/numbers/zero-float-trailing-decimal-point.json5000066400000000000000000000000031267246057100270110ustar00rootroot000000000000000. json5-0.5.0/test/parse-cases/numbers/zero-float.json000066400000000000000000000000041267246057100223730ustar00rootroot000000000000000.0 json5-0.5.0/test/parse-cases/numbers/zero-hexadecimal.json5000066400000000000000000000000041267246057100236170ustar00rootroot000000000000000x0 json5-0.5.0/test/parse-cases/numbers/zero-integer-with-integer-exponent.json000066400000000000000000000000051267246057100271660ustar00rootroot000000000000000e23 json5-0.5.0/test/parse-cases/numbers/zero-integer.json000066400000000000000000000000021267246057100227210ustar00rootroot000000000000000 json5-0.5.0/test/parse-cases/numbers/zero-octal.txt000066400000000000000000000000031267246057100222350ustar00rootroot0000000000000000 json5-0.5.0/test/parse-cases/objects/000077500000000000000000000000001267246057100174025ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/objects/duplicate-keys.json000066400000000000000000000000421267246057100232140ustar00rootroot00000000000000{ "a": true, "a": false } json5-0.5.0/test/parse-cases/objects/empty-object.json000066400000000000000000000000021267246057100226670ustar00rootroot00000000000000{}json5-0.5.0/test/parse-cases/objects/illegal-unquoted-key-number.errorSpec000066400000000000000000000001441267246057100266160ustar00rootroot00000000000000{ at: 7, lineNumber: 2, columnNumber: 5, message: "Bad identifier as unquoted key" }json5-0.5.0/test/parse-cases/objects/illegal-unquoted-key-number.txt000066400000000000000000000000361267246057100254710ustar00rootroot00000000000000{ 10twenty: "ten twenty" }json5-0.5.0/test/parse-cases/objects/illegal-unquoted-key-symbol.errorSpec000066400000000000000000000001431267246057100266320ustar00rootroot00000000000000{ at: 12, lineNumber: 2, columnNumber: 10, message: "Expected ':' instead of '-'" }json5-0.5.0/test/parse-cases/objects/illegal-unquoted-key-symbol.txt000066400000000000000000000000401267246057100255010ustar00rootroot00000000000000{ multi-word: "multi-word" }json5-0.5.0/test/parse-cases/objects/leading-comma-object.errorSpec000066400000000000000000000001441267246057100252300ustar00rootroot00000000000000{ at: 7, lineNumber: 2, columnNumber: 5, message: "Bad identifier as unquoted key" }json5-0.5.0/test/parse-cases/objects/leading-comma-object.txt000066400000000000000000000000251267246057100241010ustar00rootroot00000000000000{ ,"foo": "bar" }json5-0.5.0/test/parse-cases/objects/lone-trailing-comma-object.txt000066400000000000000000000000111267246057100252350ustar00rootroot00000000000000{ , }json5-0.5.0/test/parse-cases/objects/no-comma-object.txt000066400000000000000000000000511267246057100231110ustar00rootroot00000000000000{ "foo": "bar" "hello": "world" }json5-0.5.0/test/parse-cases/objects/reserved-unquoted-key.json5000066400000000000000000000000231267246057100246240ustar00rootroot00000000000000{ while: true }json5-0.5.0/test/parse-cases/objects/single-quoted-key.json5000066400000000000000000000000301267246057100237210ustar00rootroot00000000000000{ 'hello': "world" }json5-0.5.0/test/parse-cases/objects/trailing-comma-object.json5000066400000000000000000000000251267246057100245260ustar00rootroot00000000000000{ "foo": "bar", }json5-0.5.0/test/parse-cases/objects/unquoted-keys.json5000066400000000000000000000002261267246057100231770ustar00rootroot00000000000000{ hello: "world", _: "underscore", $: "dollar sign", one1: "numerals", _$_: "multiple symbols", $_$hello123world_$_: "mixed" }json5-0.5.0/test/parse-cases/strings/000077500000000000000000000000001267246057100174425ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/strings/escaped-single-quoted-string.json5000066400000000000000000000000171267246057100261060ustar00rootroot00000000000000'I can\'t wait'json5-0.5.0/test/parse-cases/strings/multi-line-string.json5000066400000000000000000000000171267246057100240030ustar00rootroot00000000000000'hello\ world'json5-0.5.0/test/parse-cases/strings/no-comma-array.errorSpec000066400000000000000000000001411267246057100241460ustar00rootroot00000000000000{ at: 16, lineNumber: 3, columNumber: 5, message: "Expected ']' instead of 'f'" }json5-0.5.0/test/parse-cases/strings/single-quoted-string.json5000066400000000000000000000000151267246057100245020ustar00rootroot00000000000000'hello world'json5-0.5.0/test/parse-cases/strings/unescaped-multi-line-string.errorSpec000066400000000000000000000001201267246057100266510ustar00rootroot00000000000000{ at: 5, lineNumber: 2, columnNumber: 0, message: "Bad string" }json5-0.5.0/test/parse-cases/strings/unescaped-multi-line-string.txt000066400000000000000000000000121267246057100255240ustar00rootroot00000000000000"foo bar" json5-0.5.0/test/parse-cases/todo/000077500000000000000000000000001267246057100167165ustar00rootroot00000000000000json5-0.5.0/test/parse-cases/todo/unicode-escaped-unquoted-key.json5000066400000000000000000000000541267246057100253550ustar00rootroot00000000000000{ sig\u03A3ma: "the sum of all things" }json5-0.5.0/test/parse-cases/todo/unicode-unquoted-key.json5000066400000000000000000000000771267246057100237600ustar00rootroot00000000000000{ ümlåût: "that's not really an ümlaüt, but this is" }json5-0.5.0/test/parse.js000066400000000000000000000110301267246057100152060ustar00rootroot00000000000000// parse.js // Tests parse(). See readme.txt for details. "use strict"; var assert = require('assert'); var FS = require('fs'); var JSON5 = require('..'); var Path = require('path'); // Test JSON5.parse() by comparing its output for each case with either the // native JSON.parse() or ES5 strict-mode eval(). See readme.txt for details. // For eval(), remember to wrap the input in parentheses before eval()'ing, // since {...} is ambiguous in JavaScript. Also ensure the parentheses are on // lines of their own, to support inline comments. // TODO More test cases, and ones that test specific features and edge cases. // Mozilla's test cases are a great inspiration and reference here: // http://mxr.mozilla.org/mozilla-central/source/js/src/tests/ecma_5/JSON/ var dirsPath = Path.resolve(__dirname, 'parse-cases'); var dirs = FS.readdirSync(dirsPath); var readErrorSpec = function (filePath) { var specName = Path.basename(filePath, '.txt') + '.errorSpec'; var specPath = Path.join(Path.dirname(filePath), specName); var specTxt; try { specTxt = FS.readFileSync(specPath); // note that existsSync has been deprecated } catch (e) {} if (specTxt) { try { return JSON5.parse(specTxt); } catch (err) { err.message = 'Error reading error specification file ' + specName + ': ' + err.message; throw err; } } }; var testParseJSON5 = function (filePath, str) { var errorSpec = readErrorSpec(filePath); var err; try { JSON5.parse(str); } catch (e) { err = e; } assert(err, 'Expected JSON5 parsing to fail.'); if (errorSpec) { describe("Error fixture " + filePath, function () { Object.keys(errorSpec).forEach(function (key) { if (key === 'message') { it('Expected error message\n' + err.message + '\nto start with ' + errorSpec.message, function () { assert(err.message.indexOf(errorSpec.message) === 0); }); } else { it('Expected parse error field ' + key + ' to hold value ' + errorSpec[key], function () { assert.equal(err[key], errorSpec[key]); }); } }) }); } }; function createTest(fileName, dir) { var ext = Path.extname(fileName); var filePath = Path.join(dirsPath, dir, fileName); var str = FS.readFileSync(filePath, 'utf8'); function parseJSON5() { return JSON5.parse(str); } function parseJSON() { return JSON.parse(str); } function parseES5() { return eval('"use strict"; (\n' + str + '\n)'); } exports[dir][fileName] = function test() { switch (ext) { case '.json': assert.deepEqual(parseJSON5(), parseJSON(), 'Expected parsed JSON5 to equal parsed JSON.'); break; case '.json5': assert.throws(parseJSON, // test validation 'Test case bug: expected JSON parsing to fail.'); // Need special case for NaN as NaN != NaN if ( fileName === 'nan.json5' ) { assert.equal( isNaN( parseJSON5() ), isNaN( parseES5() ), 'Expected parsed JSON5 to equal parsed ES5.'); } else { assert.deepEqual( parseJSON5(), parseES5(), 'Expected parsed JSON5 to equal parsed ES5.'); } break; case '.js': assert.throws(parseJSON, // test validation 'Test case bug: expected JSON parsing to fail.'); assert.doesNotThrow(parseES5, // test validation 'Test case bug: expected ES5 parsing not to fail.'); assert.throws(parseJSON5, 'Expected JSON5 parsing to fail.'); break; case '.txt': assert.throws(parseES5, // test validation 'Test case bug: expected ES5 parsing to fail.'); testParseJSON5(filePath, str); break; } }; } dirs.forEach(function (dir) { // create a test suite for this group of tests: exports[dir] = {}; // skip the TODO directory -- these tests are expected to fail: if (dir === 'todo') { return; } // otherwise create a test for each file in this group: FS.readdirSync(Path.join(dirsPath, dir)).forEach(function (file) { createTest(file, dir); }); }); json5-0.5.0/test/readme.md000066400000000000000000000017551267246057100153320ustar00rootroot00000000000000These tests are written for [Mocha][] using the [exports][] interface. [Mocha]: http://visionmedia.github.com/mocha/ [exports]: http://visionmedia.github.com/mocha/#exports-interface The `parse()` tests are run by comparing the output of `JSON5.parse()` with that of the native `JSON.parse()` and ES5's `eval()` in strict mode. The test cases' file extension signals the expected behavior: - Valid JSON should remain valid JSON5. These cases have a `.json` extension and are tested via `JSON.parse()`. - JSON5's new features should remain valid ES5. These cases have a `.json5` extension are tested via `eval()`. - Valid ES5 that's explicitly disallowed by JSON5 is also invalid JSON. These cases have a `.js` extension and are expected to fail. - Invalid ES5 should remain invalid JSON5. These cases have a `.txt` extension and are expected to fail. This should cover all our bases. Most of the cases are unit tests for each supported data type, but aggregate test cases are welcome, too. json5-0.5.0/test/require.js000066400000000000000000000007771267246057100155700ustar00rootroot00000000000000// require.js // Tests JSON5's require() hook. // // Important: expects the following test cases to be present: // - /parse-cases/misc/npm-package.json // - /parse-cases/misc/npm-package.json5 "use strict"; var assert = require('assert'); exports['misc'] = {}; exports['misc']['require hook'] = function () { require('../lib/require'); var json = require('./parse-cases/misc/npm-package.json'); var json5 = require('./parse-cases/misc/npm-package.json5'); assert.deepEqual(json5, json); }; json5-0.5.0/test/stringify.js000066400000000000000000000365721267246057100161340ustar00rootroot00000000000000// tests stringify() // set to true to show performance stats var DEBUG = false; var assert = require('assert'); var JSON5 = require('../lib/json5'); // Test JSON5.stringify() by comparing its output for each case with // native JSON.stringify(). The only differences will be in how object keys are // handled. var simpleCases = [ null, 9, -9, +9, +9.878, '', "''", '999', '9aa', 'aaa', 'aa a', 'aa\na', 'aa\\a', '\'', '\\\'', '\\"', undefined, true, false, {}, [], function(){}, Date.now(), new Date(Date.now()) ]; exports.stringify = {}; exports.stringify.simple = function test() { for (var i=0; i