cerxes/babel
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request babel/eslint-plugin-babel#3 from mathieumg/spaceinbrackets_export

Browse Source 
Added support for experimental exports in the `space-in-brackets` rule.
This commit is contained in:
Jason Quense 2015-07-03 23:15:14 -04:00
parent c2c9933797
commit fadd5b55ca
4 changed files with 1076 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
eslint/babel-eslint-plugin/README.md
View File

@ -28,6 +28,7 @@ Finally enable all the rules you like to use (remember to disable the originals
"babel/generator-star": 1,
"babel/generator-star-spacing": 1,
"babel/new-cap": 1,
"babel/space-in-brackets": 1,
}
}
```
@ -40,3 +41,4 @@ Each rule cooresponds to a core eslint rule, and has the same options.
- `babel/generator-star`: Handles async/await functions correctly
- `babel/generator-star-spacing`: Handles async/await functions correctly
- `babel/new-cap`: Ignores capitalized decorators (`@Decorator`)
- `babel/space-in-brackets`: doesn't complain about `export x from "mod";` or `export * as x from "mod";`

6
eslint/babel-eslint-plugin/index.js
View File

@ -6,13 +6,15 @@ module.exports = {
'object-shorthand': require('./rules/object-shorthand'),
'generator-star-spacing': require('./rules/generator-star-spacing'),
'generator-star': require('./rules/generator-star'),
'new-cap': require('./rules/new-cap')
'new-cap': require('./rules/new-cap'),
'space-in-brackets': require('./rules/space-in-brackets'),
},
rulesConfig: {
'block-scoped-var': 0,
'generator-star-spacing': 0,
'generator-star': 0,
'object-shorthand': 0,
'new-cap': 0
'new-cap': 0,
'space-in-brackets': 0
}
};

309
eslint/babel-eslint-plugin/rules/space-in-brackets.js Normal file
View File

@ -0,0 +1,309 @@
/**
* @fileoverview Disallows or enforces spaces inside of brackets.
* @author Ian Christian Myers
* @copyright 2015 Mathieu M-Gosselin. All rights reserved.
* @copyright 2014 Brandyn Bennett. All rights reserved.
* @copyright 2014 Michael Ficarra. No rights reserved.
* @copyright 2014 Vignesh Anand. All rights reserved.
*/
"use strict";
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
module.exports = function(context) {
var spaced = context.options[0] === "always";
/**
* Determines whether an option is set, relative to the spacing option.
* If spaced is "always", then check whether option is set to false.
* If spaced is "never", then check whether option is set to true.
* @param {Object} option - The option to exclude.
* @returns {boolean} Whether or not the property is excluded.
*/
function isOptionSet(option) {
return context.options[1] != null ? context.options[1][option] === !spaced : false;
}
var options = {
spaced: spaced,
singleElementException: isOptionSet("singleValue"),
objectsInArraysException: isOptionSet("objectsInArrays"),
arraysInArraysException: isOptionSet("arraysInArrays"),
arraysInObjectsException: isOptionSet("arraysInObjects"),
objectsInObjectsException: isOptionSet("objectsInObjects"),
propertyNameException: isOptionSet("propertyName")
};
//--------------------------------------------------------------------------
// Helpers
//--------------------------------------------------------------------------
/**
* Determines whether two adjacent tokens are have whitespace between them.
* @param {Object} left - The left token object.
* @param {Object} right - The right token object.
* @returns {boolean} Whether or not there is space between the tokens.
*/
function isSpaced(left, right) {
return left.range[1] < right.range[0];
}
/**
* Determines whether two adjacent tokens are on the same line.
* @param {Object} left - The left token object.
* @param {Object} right - The right token object.
* @returns {boolean} Whether or not the tokens are on the same line.
*/
function isSameLine(left, right) {
return left.loc.start.line === right.loc.start.line;
}
/**
* Reports that there shouldn't be a space after the first token
* @param {ASTNode} node - The node to report in the event of an error.
* @param {Token} token - The token to use for the report.
* @returns {void}
*/
function reportNoBeginningSpace(node, token) {
context.report(node, token.loc.start,
"There should be no space after '" + token.value + "'");
}
/**
* Reports that there shouldn't be a space before the last token
* @param {ASTNode} node - The node to report in the event of an error.
* @param {Token} token - The token to use for the report.
* @returns {void}
*/
function reportNoEndingSpace(node, token) {
context.report(node, token.loc.start,
"There should be no space before '" + token.value + "'");
}
/**
* Reports that there should be a space after the first token
* @param {ASTNode} node - The node to report in the event of an error.
* @param {Token} token - The token to use for the report.
* @returns {void}
*/
function reportRequiredBeginningSpace(node, token) {
context.report(node, token.loc.start,
"A space is required after '" + token.value + "'");
}
/**
* Reports that there should be a space before the last token
* @param {ASTNode} node - The node to report in the event of an error.
* @param {Token} token - The token to use for the report.
* @returns {void}
*/
function reportRequiredEndingSpace(node, token) {
context.report(node, token.loc.start,
"A space is required before '" + token.value + "'");
}
/**
* Determines if spacing in curly braces is valid.
* @param {ASTNode} node The AST node to check.
* @param {Token} first The first token to check (should be the opening brace)
* @param {Token} second The second token to check (should be first after the opening brace)
* @param {Token} penultimate The penultimate token to check (should be last before closing brace)
* @param {Token} last The last token to check (should be closing brace)
* @returns {void}
*/
function validateBraceSpacing(node, first, second, penultimate, last) {
var closingCurlyBraceMustBeSpaced =
options.arraysInObjectsException && penultimate.value === "]" ||
options.objectsInObjectsException && penultimate.value === "}"
? !options.spaced : options.spaced;
if (isSameLine(first, second)) {
if (options.spaced && !isSpaced(first, second)) {
reportRequiredBeginningSpace(node, first);
}
if (!options.spaced && isSpaced(first, second)) {
reportNoBeginningSpace(node, first);
}
}
if (isSameLine(penultimate, last)) {
if (closingCurlyBraceMustBeSpaced && !isSpaced(penultimate, last)) {
reportRequiredEndingSpace(node, last);
}
if (!closingCurlyBraceMustBeSpaced && isSpaced(penultimate, last)) {
reportNoEndingSpace(node, last);
}
}
}
//--------------------------------------------------------------------------
// Public
//--------------------------------------------------------------------------
return {
MemberExpression: function(node) {
if (!node.computed) {
return;
}
var property = node.property,
before = context.getTokenBefore(property),
first = context.getFirstToken(property),
last = context.getLastToken(property),
after = context.getTokenAfter(property);
var propertyNameMustBeSpaced = options.propertyNameException ?
!options.spaced : options.spaced;
if (isSameLine(before, first)) {
if (propertyNameMustBeSpaced) {
if (!isSpaced(before, first) && isSameLine(before, first)) {
reportRequiredBeginningSpace(node, before);
}
} else {
if (isSpaced(before, first)) {
reportNoBeginningSpace(node, before);
}
}
}
if (isSameLine(last, after)) {
if (propertyNameMustBeSpaced) {
if (!isSpaced(last, after) && isSameLine(last, after)) {
reportRequiredEndingSpace(node, after);
}
} else {
if (isSpaced(last, after)) {
reportNoEndingSpace(node, after);
}
}
}
},
ArrayExpression: function(node) {
if (node.elements.length === 0) {
return;
}
var first = context.getFirstToken(node),
second = context.getFirstToken(node, 1),
penultimate = context.getLastToken(node, 1),
last = context.getLastToken(node);
var openingBracketMustBeSpaced =
options.objectsInArraysException && second.value === "{" ||
options.arraysInArraysException && second.value === "[" ||
options.singleElementException && node.elements.length === 1
? !options.spaced : options.spaced;
var closingBracketMustBeSpaced =
options.objectsInArraysException && penultimate.value === "}" ||
options.arraysInArraysException && penultimate.value === "]" ||
options.singleElementException && node.elements.length === 1
? !options.spaced : options.spaced;
if (isSameLine(first, second)) {
if (openingBracketMustBeSpaced && !isSpaced(first, second)) {
reportRequiredBeginningSpace(node, first);
}
if (!openingBracketMustBeSpaced && isSpaced(first, second)) {
reportNoBeginningSpace(node, first);
}
}
if (isSameLine(penultimate, last)) {
if (closingBracketMustBeSpaced && !isSpaced(penultimate, last)) {
reportRequiredEndingSpace(node, last);
}
if (!closingBracketMustBeSpaced && isSpaced(penultimate, last)) {
reportNoEndingSpace(node, last);
}
}
},
ImportDeclaration: function(node) {
var firstSpecifier = node.specifiers[0],
lastSpecifier = node.specifiers[node.specifiers.length - 1];
// don't do anything for namespace or default imports
if (firstSpecifier && lastSpecifier && firstSpecifier.type === "ImportSpecifier" && lastSpecifier.type === "ImportSpecifier") {
var first = context.getTokenBefore(firstSpecifier),
second = context.getFirstToken(firstSpecifier),
penultimate = context.getLastToken(lastSpecifier),
last = context.getTokenAfter(lastSpecifier);
validateBraceSpacing(node, first, second, penultimate, last);
}
},
ExportNamedDeclaration: function(node) {
if (!node.specifiers.length) {
return;
}
var firstSpecifier = node.specifiers[0],
lastSpecifier = node.specifiers[node.specifiers.length - 1],
first = context.getTokenBefore(firstSpecifier),
second = context.getFirstToken(firstSpecifier),
penultimate = context.getLastToken(lastSpecifier),
last = context.getTokenAfter(lastSpecifier);
if (first.value === "export") {
return;
}
validateBraceSpacing(node, first, second, penultimate, last);
},
ObjectExpression: function(node) {
if (node.properties.length === 0) {
return;
}
var first = context.getFirstToken(node),
second = context.getFirstToken(node, 1),
penultimate = context.getLastToken(node, 1),
last = context.getLastToken(node);
validateBraceSpacing(node, first, second, penultimate, last);
}
};
};
module.exports.schema = [
{
"enum": ["always", "never"]
},
{
"type": "object",
"properties": {
"singleValue": {
"type": "boolean"
},
"objectsInArrays": {
"type": "boolean"
},
"arraysInArrays": {
"type": "boolean"
},
"arraysInObjects": {
"type": "boolean"
},
"objectsInObjects": {
"type": "boolean"
},
"propertyName": {
"type": "boolean"
}
},
"additionalProperties": false
}
];

761
eslint/babel-eslint-plugin/tests/space-in-brackets.js Normal file
View File

@ -0,0 +1,761 @@
/* eslint-disable */
/**
* @fileoverview Disallows or enforces spaces inside of brackets.
* @author Ian Christian Myers
* @copyright 2014 Vignesh Anand. All rights reserved.
*/
var linter = require('eslint').linter
, ESLintTester = require('eslint-tester')
, eslintTester = new ESLintTester(linter);
eslintTester.addRuleTest("rules/space-in-brackets", {
valid: [
{ code: "var foo = obj[ 1 ]", options: ["always"] },
{ code: "var foo = obj[ 'foo' ];", options: ["always"] },
{ code: "var foo = obj[ [ 1, 1 ] ];", options: ["always"] },
// always - singleValue
{ code: "var foo = ['foo']", options: ["always", {singleValue: false}] },
{ code: "var foo = [2]", options: ["always", {singleValue: false}] },
{ code: "var foo = [[ 1, 1 ]]", options: ["always", {singleValue: false}] },
{ code: "var foo = [{ 'foo': 'bar' }]", options: ["always", {singleValue: false}] },
{ code: "var foo = [bar]", options: ["always", {singleValue: false}] },
// always - objectsInArrays
{ code: "var foo = [{ 'bar': 'baz' }, 1, 5 ];", options: ["always", {objectsInArrays: false}] },
{ code: "var foo = [ 1, 5, { 'bar': 'baz' }];", options: ["always", {objectsInArrays: false}] },
{ code: "var foo = [{\n'bar': 'baz', \n'qux': [{ 'bar': 'baz' }], \n'quxx': 1 \n}]", options: ["always", {objectsInArrays: false}] },
{ code: "var foo = [{ 'bar': 'baz' }]", options: ["always", {objectsInArrays: false}] },
{ code: "var foo = [{ 'bar': 'baz' }, 1, { 'bar': 'baz' }];", options: ["always", {objectsInArrays: false}] },
{ code: "var foo = [ 1, { 'bar': 'baz' }, 5 ];", options: ["always", {objectsInArrays: false}] },
{ code: "var foo = [ 1, { 'bar': 'baz' }, [{ 'bar': 'baz' }] ];", options: ["always", {objectsInArrays: false}] },
// always - arraysInArrays
{ code: "var arr = [[ 1, 2 ], 2, 3, 4 ];", options: ["always", {"arraysInArrays": false}] },
{ code: "var arr = [[ 1, 2 ], [[[ 1 ]]], 3, 4 ];", options: ["always", {"arraysInArrays": false}] },
// always - arraysInArrays, objectsInArrays
{ code: "var arr = [[ 1, 2 ], 2, 3, { 'foo': 'bar' }];", options: ["always", {"arraysInArrays": false, objectsInArrays: false}] },
// always - arraysInArrays, objectsInArrays, singleValue
{ code: "var arr = [[ 1, 2 ], [2], 3, { 'foo': 'bar' }];", options: ["always", {"arraysInArrays": false, objectsInArrays: false, singleValue: false}] },
// always - arraysInObjects
{ code: "var obj = { 'foo': [ 1, 2 ]};", options: ["always", {"arraysInObjects": false}] },
// always - objectsInObjects
{ code: "var obj = { 'foo': { 'bar': 1, 'baz': 2 }};", options: ["always", {"objectsInObjects": false}] },
// always - arraysInObjects, objectsInObjects
{ code: "var obj = { 'qux': [ 1, 2 ], 'foo': { 'bar': 1, 'baz': 2 }};", options: ["always", {"arraysInObjects": false, "objectsInObjects": false}] },
// always - arraysInObjects, objectsInObjects (reverse)
{ code: "var obj = { 'foo': { 'bar': 1, 'baz': 2 }, 'qux': [ 1, 2 ]};", options: ["always", {"arraysInObjects": false, "objectsInObjects": false}] },
// always
{ code: "obj[ foo ]", options: ["always"] },
{ code: "obj[\nfoo\n]", options: ["always"] },
{ code: "obj[ 'foo' ]", options: ["always"] },
{ code: "obj[ 'foo' + 'bar' ]", options: ["always"] },
{ code: "obj[ obj2[ foo ] ]", options: ["always"] },
{ code: "obj.map(function (item) { return [\n1,\n2,\n3,\n4\n]; })", options: ["always"] },
{ code: "obj[ 'map' ](function (item) { return [\n1,\n2,\n3,\n4\n]; })", options: ["always"] },
{ code: "obj[ 'for' + 'Each' ](function (item) { return [\n1,\n2,\n3,\n4\n]; })", options: ["always"] },
{ code: "var arr = [ 1, 2, 3, 4 ];", options: ["always"] },
{ code: "var arr = [ [ 1, 2 ], 2, 3, 4 ];", options: ["always"] },
{ code: "var arr = [\n1, 2, 3, 4\n];", options: ["always"] },
{ code: "var obj = { foo: bar, baz: qux };", options: ["always"] },
{ code: "var obj = { foo: { bar: quxx }, baz: qux };", options: ["always"] },
{ code: "var obj = {\nfoo: bar,\nbaz: qux\n};", options: ["always"] },
{ code: "var foo = {};", options: ["always"] },
{ code: "var foo = [];", options: ["always"] },
{ code: "this.db.mappings.insert([\n { alias: 'a', url: 'http://www.amazon.de' },\n { alias: 'g', url: 'http://www.google.de' }\n], function () {});", options: ["always", {singleValue: false, objectsInArrays: true, arraysInArrays: true}] },
// never
{ code: "obj[foo]", options: ["never"] },
{ code: "obj['foo']", options: ["never"] },
{ code: "obj['foo' + 'bar']", options: ["never"] },
{ code: "obj['foo'+'bar']", options: ["never"] },
{ code: "obj[obj2[foo]]", options: ["never"] },
{ code: "obj.map(function (item) { return [\n1,\n2,\n3,\n4\n]; })", options: ["never"] },
{ code: "obj['map'](function (item) { return [\n1,\n2,\n3,\n4\n]; })", options: ["never"] },
{ code: "obj['for' + 'Each'](function (item) { return [\n1,\n2,\n3,\n4\n]; })", options: ["never"] },
{ code: "obj[ obj2[ foo ] ]", options: ["never", {"propertyName": true}] },
{ code: "obj['for' + 'Each'](function (item) { return [\n1,\n2,\n3,\n4\n]; })", options: ["never"] },
{ code: "obj[\nfoo]", options: ["never"] },
{ code: "obj[foo\n]", options: ["never"] },
{ code: "var obj = {foo: bar,\nbaz: qux\n};", options: ["never"] },
{ code: "var obj = {\nfoo: bar,\nbaz: qux};", options: ["never"] },
{ code: "var arr = [1,\n2,\n3,\n4\n];", options: ["never"] },
{ code: "var arr = [\n1,\n2,\n3,\n4];", options: ["never"] },
// never - singleValue
{ code: "var foo = [ 'foo' ]", options: ["never", {singleValue: true}] },
{ code: "var foo = [ 2 ]", options: ["never", {singleValue: true}] },
{ code: "var foo = [ [1, 1] ]", options: ["never", {singleValue: true}] },
{ code: "var foo = [ {'foo': 'bar'} ]", options: ["never", {singleValue: true}] },
{ code: "var foo = [ bar ]", options: ["never", {singleValue: true}] },
// never - objectsInArrays
{ code: "var foo = [ {'bar': 'baz'}, 1, 5];", options: ["never", {objectsInArrays: true}] },
{ code: "var foo = [1, 5, {'bar': 'baz'} ];", options: ["never", {objectsInArrays: true}] },
{ code: "var foo = [ {\n'bar': 'baz', \n'qux': [ {'bar': 'baz'} ], \n'quxx': 1 \n} ]", options: ["never", {objectsInArrays: true}] },
{ code: "var foo = [ {'bar': 'baz'} ]", options: ["never", {objectsInArrays: true}] },
{ code: "var foo = [ {'bar': 'baz'}, 1, {'bar': 'baz'} ];", options: ["never", {objectsInArrays: true}] },
{ code: "var foo = [1, {'bar': 'baz'} , 5];", options: ["never", {objectsInArrays: true}] },
{ code: "var foo = [1, {'bar': 'baz'}, [ {'bar': 'baz'} ]];", options: ["never", {objectsInArrays: true}] },
// never - arraysInArrays
{ code: "var arr = [ [1, 2], 2, 3, 4];", options: ["never", {"arraysInArrays": true}] },
// never - arraysInArrays, singleValue
{ code: "var arr = [ [1, 2], [ [ [ 1 ] ] ], 3, 4];", options: ["never", {"arraysInArrays": true, singleValue: true}] },
// never - arraysInArrays, objectsInArrays
{ code: "var arr = [ [1, 2], 2, 3, {'foo': 'bar'} ];", options: ["never", {"arraysInArrays": true, objectsInArrays: true}] },
{ code: "var arr = [1, 2, 3, 4];", options: ["never"] },
{ code: "var arr = [[1, 2], 2, 3, 4];", options: ["never"] },
{ code: "var arr = [\n1, 2, 3, 4\n];", options: ["never"] },
{ code: "var obj = {foo: bar, baz: qux};", options: ["never"] },
{ code: "var obj = {foo: {bar: quxx}, baz: qux};", options: ["never"] },
{ code: "var obj = {\nfoo: bar,\nbaz: qux\n};", options: ["never"] },
{ code: "var foo = {};", options: ["never"] },
{ code: "var foo = [];", options: ["never"] },
{ code: "var foo = [{'bar':'baz'}, 1, {'bar': 'baz'}];", options: ["never"] },
{ code: "var foo = [{'bar': 'baz'}];", options: ["never"] },
{ code: "var foo = [{\n'bar': 'baz', \n'qux': [{'bar': 'baz'}], \n'quxx': 1 \n}]", options: ["never"] },
{ code: "var foo = [1, {'bar': 'baz'}, 5];", options: ["never"] },
{ code: "var foo = [{'bar': 'baz'}, 1, 5];", options: ["never"] },
{ code: "var foo = [1, 5, {'bar': 'baz'}];", options: ["never"] },
{ code: "var obj = {'foo': [1, 2]}", options: ["never"] },
// propertyName: false
{ code: "var foo = obj[1]", options: ["always", {propertyName: false}] },
{ code: "var foo = obj['foo'];", options: ["always", {propertyName: false}] },
{ code: "var foo = obj[[ 1, 1 ]];", options: ["always", {propertyName: false}] },
{ code: "var foo = obj[ 1 ]", options: ["never", {propertyName: true}] },
{ code: "var foo = obj[ 'foo' ];", options: ["never", {propertyName: true}] },
{ code: "var foo = obj[ [1, 1] ];", options: ["never", {propertyName: true}] },
{ code: "import 'test.js';", ecmaFeatures: { modules: true } },
{ code: "export const thing = {\n value: 1 \n};", ecmaFeatures: { modules: true, blockBindings: true } },
{ code: "export const thing = {};", ecmaFeatures: { modules: true, blockBindings: true } },
{ code: "export let thing = {};", ecmaFeatures: { modules: true, blockBindings: true } },
{ code: "export var thing = {};", ecmaFeatures: { modules: true } },
// Babel test cases.
{ code: "export * as x from \"mod\";", parser: "babel-eslint", ecmaFeatures: { modules: true } },
{ code: "export x from \"mod\";", parser: "babel-eslint", ecmaFeatures: { modules: true } },
],
invalid: [
// objectsInArrays
{
code: "var foo = [ { 'bar': 'baz' }, 1, 5];",
options: ["always", {objectsInArrays: false}],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
},
{
message: "A space is required before ']'",
type: "ArrayExpression"
}
]
},
{
code: "import {bar} from 'foo.js';",
options: ["always"],
ecmaFeatures: {
modules: true
},
errors: [
{
message: "A space is required after '{'",
type: "ImportDeclaration"
},
{
message: "A space is required before '}'",
type: "ImportDeclaration"
}
]
},
{
code: "export {bar};",
options: ["always"],
ecmaFeatures: {
modules: true
},
errors: [
{
message: "A space is required after '{'",
type: "ExportNamedDeclaration"
},
{
message: "A space is required before '}'",
type: "ExportNamedDeclaration"
}
]
},
{
code: "var foo = [1, 5, { 'bar': 'baz' } ];",
options: ["always", {objectsInArrays: false}],
errors: [
{
message: "A space is required after '['",
type: "ArrayExpression"
},
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var foo = [ { 'bar':'baz' }, 1, { 'bar': 'baz' } ];",
options: ["always", {objectsInArrays: false}],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
},
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
// singleValue
{
code: "var obj = [ 'foo' ];",
options: ["always", {singleValue: false}],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
},
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var obj = ['foo' ];",
options: ["always", {singleValue: false}],
errors: [
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
// singleValue
{
code: "var obj = ['foo'];",
options: ["never", {singleValue: true}],
errors: [
{
message: "A space is required after '['",
type: "ArrayExpression"
},
{
message: "A space is required before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var foo = obj[ 1];",
options: ["always"],
errors: [
{
message: "A space is required before ']'",
type: "MemberExpression"
}
]
},
{
code: "var foo = obj[1 ];",
options: ["always"],
errors: [
{
message: "A space is required after '['",
type: "MemberExpression"
}
]
},
// propertyName
{
code: "var foo = obj[ 1];",
options: ["always", {propertyName: false}],
errors: [
{
message: "There should be no space after '['",
type: "MemberExpression"
}
]
},
{
code: "var foo = obj[1 ];",
options: ["always", {propertyName: false}],
errors: [
{
message: "There should be no space before ']'",
type: "MemberExpression"
}
]
},
{
code: "var foo = obj[ 1];",
options: ["never", {propertyName: true}],
errors: [
{
message: "A space is required before ']'",
type: "MemberExpression"
}
]
},
{
code: "var foo = obj[1 ];",
options: ["never", {propertyName: true}],
errors: [
{
message: "A space is required after '['",
type: "MemberExpression"
}
]
},
// always - arraysInArrays
{
code: "var arr = [ [ 1, 2 ], 2, 3, 4 ];",
options: ["always", {"arraysInArrays": false}],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [ 1, 2, 2, [ 3, 4 ] ];",
options: ["always", {"arraysInArrays": false}],
errors: [
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [[ 1, 2 ], 2, [ 3, 4 ] ];",
options: ["always", {"arraysInArrays": false}],
errors: [
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [ [ 1, 2 ], 2, [ 3, 4 ]];",
options: ["always", {"arraysInArrays": false}],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [ [ 1, 2 ], 2, [ 3, 4 ] ];",
options: ["always", {"arraysInArrays": false}],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
},
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
// never - arraysInArrays
{
code: "var arr = [[1, 2], 2, [3, 4]];",
options: ["never", {"arraysInArrays": true}],
errors: [
{
message: "A space is required after '['",
type: "ArrayExpression"
},
{
message: "A space is required before ']'",
type: "ArrayExpression"
}
]
},
// always - arraysInObjects
{
code: "var obj = { 'foo': [ 1, 2 ] };",
options: ["always", {"arraysInObjects": false}],
errors: [
{
message: "There should be no space before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = { 'foo': [ 1, 2 ] , 'bar': [ 'baz', 'qux' ] };",
options: ["always", {"arraysInObjects": false}],
errors: [
{
message: "There should be no space before '}'",
type: "ObjectExpression"
}
]
},
// never - arraysInObjects
{
code: "var obj = {'foo': [1, 2]};",
options: ["never", {"arraysInObjects": true}],
errors: [
{
message: "A space is required before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = {'foo': [1, 2] , 'bar': ['baz', 'qux']};",
options: ["never", {"arraysInObjects": true}],
errors: [
{
message: "A space is required before '}'",
type: "ObjectExpression"
}
]
},
// always-objectsInObjects
{
code: "var obj = { 'foo': { 'bar': 1, 'baz': 2 } };",
options: ["always", {"objectsInObjects": false}],
errors: [
{
message: "There should be no space before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = { 'foo': [ 1, 2 ] , 'bar': { 'baz': 1, 'qux': 2 } };",
options: ["always", {"objectsInObjects": false}],
errors: [
{
message: "There should be no space before '}'",
type: "ObjectExpression"
}
]
},
// never-objectsInObjects
{
code: "var obj = {'foo': {'bar': 1, 'baz': 2}};",
options: ["never", {"objectsInObjects": true}],
errors: [
{
message: "A space is required before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = {'foo': [1, 2] , 'bar': {'baz': 1, 'qux': 2}};",
options: ["never", {"objectsInObjects": true}],
errors: [
{
message: "A space is required before '}'",
type: "ObjectExpression"
}
]
},
// always & never
{
code: "var obj = {foo: bar, baz: qux};",
options: ["always"],
errors: [
{
message: "A space is required after '{'",
type: "ObjectExpression"
},
{
message: "A space is required before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = {foo: bar, baz: qux };",
options: ["always"],
errors: [
{
message: "A space is required after '{'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = { foo: bar, baz: qux};",
options: ["always"],
errors: [
{
message: "A space is required before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = { foo: bar, baz: qux };",
options: ["never"],
errors: [
{
message: "There should be no space after '{'",
type: "ObjectExpression"
},
{
message: "There should be no space before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = {foo: bar, baz: qux };",
options: ["never"],
errors: [
{
message: "There should be no space before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = { foo: bar, baz: qux};",
options: ["never"],
errors: [
{
message: "There should be no space after '{'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = { foo: { bar: quxx}, baz: qux};",
options: ["never"],
errors: [
{
message: "There should be no space after '{'",
type: "ObjectExpression"
},
{
message: "There should be no space after '{'",
type: "ObjectExpression"
}
]
},
{
code: "var obj = {foo: {bar: quxx }, baz: qux };",
options: ["never"],
errors: [
{
message: "There should be no space before '}'",
type: "ObjectExpression"
},
{
message: "There should be no space before '}'",
type: "ObjectExpression"
}
]
},
{
code: "var arr = [1, 2, 3, 4];",
options: ["always"],
errors: [
{
message: "A space is required after '['",
type: "ArrayExpression"
},
{
message: "A space is required before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [1, 2, 3, 4 ];",
options: ["always"],
errors: [
{
message: "A space is required after '['",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [ 1, 2, 3, 4];",
options: ["always"],
errors: [
{
message: "A space is required before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [ 1, 2, 3, 4 ];",
options: ["never"],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
},
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [1, 2, 3, 4 ];",
options: ["never"],
errors: [
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [ 1, 2, 3, 4];",
options: ["never"],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [ [ 1], 2, 3, 4];",
options: ["never"],
errors: [
{
message: "There should be no space after '['",
type: "ArrayExpression"
},
{
message: "There should be no space after '['",
type: "ArrayExpression"
}
]
},
{
code: "var arr = [[1 ], 2, 3, 4 ];",
options: ["never"],
errors: [
{
message: "There should be no space before ']'",
type: "ArrayExpression"
},
{
message: "There should be no space before ']'",
type: "ArrayExpression"
}
]
},
{
code: "obj[ foo ]",
options: ["never"],
errors: [
{
message: "There should be no space after '['",
type: "MemberExpression"
},
{
message: "There should be no space before ']'",
type: "MemberExpression"
}
]
},
{
code: "obj[foo ]",
options: ["never"],
errors: [
{
message: "There should be no space before ']'",
type: "MemberExpression"
}
]
},
{
code: "obj[ foo]",
options: ["never"],
errors: [
{
message: "There should be no space after '['",
type: "MemberExpression"
}
]
},
{
code: "var foo = obj[1]",
options: ["always"],
errors: [
{
message: "A space is required after '['",
type: "MemberExpression"
},
{
message: "A space is required before ']'",
type: "MemberExpression"
}
]
},
{
code: "export const thing = {value: 1 };",
ecmaFeatures: {
modules: true,
blockBindings: true
},
options: ["always"],
errors: [
{
message: "A space is required after '{'",
type: "ObjectExpression"
}
]
}
]
});