pax_global_header00006660000000000000000000000064130166534530014520gustar00rootroot0000000000000052 comment=18fd19e687674c053c2b30a7c0d49f7da481ae5b json5-0.5.1/000077500000000000000000000000001301665345300125615ustar00rootroot00000000000000json5-0.5.1/.editorconfig000066400000000000000000000005351301665345300152410ustar00rootroot00000000000000# 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.1/.gitignore000066400000000000000000000000331301665345300145450ustar00rootroot00000000000000node_modules npm-debug.log json5-0.5.1/.gitmodules000066400000000000000000000001441301665345300147350ustar00rootroot00000000000000[submodule "test/parse-cases"] path = test/parse-cases url = https://github.com/json5/json5-tests json5-0.5.1/.jshintrc000066400000000000000000000000461301665345300144060ustar00rootroot00000000000000{ "browser": true, "node": true } json5-0.5.1/.travis.yml000066400000000000000000000001151301665345300146670ustar00rootroot00000000000000sudo: false language: node_js node_js: - "0.10" - "0.12" - "4" - "5" json5-0.5.1/CHANGELOG.md000066400000000000000000000142771301665345300144050ustar00rootroot00000000000000### v0.5.1 [[code][c0.5.1], [diff][d0.5.1]] [c0.5.1]: https://github.com/aseemk/json5/tree/v0.5.1 [d0.5.1]: https://github.com/aseemk/json5/compare/v0.5.0...v0.5.1 This release includes a minor fix for indentations when stringifying empty arrays. - Fix: Indents no longer appear in empty arrays when stringified. ([#134]) ### 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.1/LICENSE.md000066400000000000000000000021601301665345300141640ustar00rootroot00000000000000MIT License Copyright (c) 2012-2016 Aseem Kishore, and [others](https://github.com/aseemk/json5/contributors). 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: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 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. json5-0.5.1/README.md000066400000000000000000000212761301665345300140500ustar00rootroot00000000000000# JSON5 – Modern JSON [![Build Status](https://travis-ci.org/json5/json5.svg)](https://travis-ci.org/json5/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.)* - Object keys can also be single-quoted. - 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. See [LICENSE.md](./LICENSE.md) for details. ## 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.1/gulpfile.js000066400000000000000000000003071301665345300147260ustar00rootroot00000000000000var 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.1/lib/000077500000000000000000000000001301665345300133275ustar00rootroot00000000000000json5-0.5.1/lib/cli.js000077500000000000000000000022071301665345300144400ustar00rootroot00000000000000#!/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.1/lib/json5.js000066400000000000000000000600601301665345300147250ustar00rootroot00000000000000// 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(); if (obj_part.length) { buffer += makeIndent(indentStr, objStack.length, true) } buffer += "]"; } 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.1/lib/require.js000066400000000000000000000011341301665345300153400ustar00rootroot00000000000000// 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.1/package.json000066400000000000000000000017061301665345300150530ustar00rootroot00000000000000{ "name": "json5", "version": "0.5.1", "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.1", "jshint": "^2.9.3", "jshint-stylish": "^2.2.1", "mocha": "^3.1.0" }, "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.1/package.json5000066400000000000000000000023441301665345300151370ustar00rootroot00000000000000// 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.1', 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.1', jshint: '^2.9.3', 'jshint-stylish': '^2.2.1', mocha: '^3.1.0' }, 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.1/test/000077500000000000000000000000001301665345300135405ustar00rootroot00000000000000json5-0.5.1/test/count-newlines.js000066400000000000000000000016411301665345300170520ustar00rootroot00000000000000// 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.1/test/parse-cases/000077500000000000000000000000001301665345300157465ustar00rootroot00000000000000json5-0.5.1/test/parse.js000066400000000000000000000112441301665345300152120ustar00rootroot00000000000000// 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).filter(function(fn) { if (fn.substr(0, 1) == '.') { return false; } return FS.statSync(Path.join(dirsPath, fn)).isDirectory(); }); 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.1/test/readme.md000066400000000000000000000017551301665345300153270ustar00rootroot00000000000000These 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.1/test/require.js000066400000000000000000000007771301665345300155650ustar00rootroot00000000000000// 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.1/test/stringify.js000066400000000000000000000366231301665345300161260ustar00rootroot00000000000000// 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