@ -1,8 +1,6 @@
/ * * / * *
* @ fileoverview Rule to enforce spacing before and after keywords . * @ fileoverview Rule to enforce spacing before and after keywords .
* @ author Toru Nagashima * @ author Toru Nagashima
* @ copyright 2015 Toru Nagashima . All rights reserved .
* See LICENSE file in root directory for full license .
* / * /
"use strict" ; "use strict" ;
@ -65,470 +63,482 @@ function isCloseParenOfTemplate(token) {
// Rule Definition
// Rule Definition
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
module . exports = function ( context ) { module . exports = {
var sourceCode = context . getSourceCode ( ) ; meta : {
docs : {
/ * * description : "enforce consistent spacing before and after keywords" ,
* Reports a given token if there are not space ( s ) before the token . category : "Stylistic Issues" ,
* recommended : false
* @ param { Token } token - A token to report . } ,
* @ param { RegExp | undefined } pattern - Optional . A pattern of the previous
* token to check .
* @ returns { void }
* /
function expectSpaceBefore ( token , pattern ) {
pattern = pattern || PREV_TOKEN ;
var prevToken = sourceCode . getTokenBefore ( token ) ;
if ( prevToken &&
( CHECK_TYPE . test ( prevToken . type ) || pattern . test ( prevToken . value ) ) &&
! isOpenParenOfTemplate ( prevToken ) &&
astUtils . isTokenOnSameLine ( prevToken , token ) &&
! sourceCode . isSpaceBetweenTokens ( prevToken , token )
) {
context . report ( {
loc : token . loc . start ,
message : "Expected space(s) before \"{{value}}\"." ,
data : token ,
fix : function ( fixer ) {
return fixer . insertTextBefore ( token , " " ) ;
}
} ) ;
}
}
/ * * fixable : "whitespace" ,
* Reports a given token if there are space ( s ) before the token .
* schema : [
* @ param { Token } token - A token to report . {
* @ param { RegExp | undefined } pattern - Optional . A pattern of the previous type : "object" ,
* token to check . properties : {
* @ returns { void } before : { type : "boolean" } ,
* / after : { type : "boolean" } ,
function unexpectSpaceBefore ( token , pattern ) { overrides : {
pattern = pattern || PREV_TOKEN ; type : "object" ,
properties : KEYS . reduce ( function ( retv , key ) {
var prevToken = sourceCode . getTokenBefore ( token ) ; retv [ key ] = {
type : "object" ,
if ( prevToken && properties : {
( CHECK_TYPE . test ( prevToken . type ) || pattern . test ( prevToken . value ) ) && before : { type : "boolean" } ,
! isOpenParenOfTemplate ( prevToken ) && after : { type : "boolean" }
astUtils . isTokenOnSameLine ( prevToken , token ) && } ,
sourceCode . isSpaceBetweenTokens ( prevToken , token ) additionalProperties : false
) { } ;
context . report ( { return retv ;
loc : token . loc . start , } , { } ) ,
message : "Unexpected space(s) before \"{{value}}\"." , additionalProperties : false
data : token , }
fix : function ( fixer ) { } ,
return fixer . removeRange ( [ prevToken . range [ 1 ] , token . range [ 0 ] ] ) ; additionalProperties : false
} }
} ) ; ]
} ,
create : function ( context ) {
var sourceCode = context . getSourceCode ( ) ;
/ * *
* Reports a given token if there are not space ( s ) before the token .
*
* @ param { Token } token - A token to report .
* @ param { RegExp | undefined } pattern - Optional . A pattern of the previous
* token to check .
* @ returns { void }
* /
function expectSpaceBefore ( token , pattern ) {
pattern = pattern || PREV_TOKEN ;
var prevToken = sourceCode . getTokenBefore ( token ) ;
if ( prevToken &&
( CHECK_TYPE . test ( prevToken . type ) || pattern . test ( prevToken . value ) ) &&
! isOpenParenOfTemplate ( prevToken ) &&
astUtils . isTokenOnSameLine ( prevToken , token ) &&
! sourceCode . isSpaceBetweenTokens ( prevToken , token )
) {
context . report ( {
loc : token . loc . start ,
message : "Expected space(s) before \"{{value}}\"." ,
data : token ,
fix : function ( fixer ) {
return fixer . insertTextBefore ( token , " " ) ;
}
} ) ;
}
} }
}
/ * * / * *
* Reports a given token if there are not space ( s ) after the token . * Reports a given token if there are space ( s ) before the token .
* *
* @ param { Token } token - A token to report . * @ param { Token } token - A token to report .
* @ param { RegExp | undefined } pattern - Optional . A pattern of the next * @ param { RegExp | undefined } pattern - Optional . A pattern of the previous
* token to check . * token to check .
* @ returns { void } * @ returns { void }
* / * /
function expectSpaceAfter ( token , pattern ) { function unexpectSpaceBefore ( token , pattern ) {
pattern = pattern || NEXT_TOKEN ; pattern = pattern || PREV_TOKEN ;
var nextToken = sourceCode . getTokenAfter ( token ) ; var prevToken = sourceCode . getTokenBefore ( token ) ;
if ( nextToken && if ( prevToken &&
( CHECK_TYPE . test ( nextToken . type ) || pattern . test ( nextToken . value ) ) && ( CHECK_TYPE . test ( prevToken . type ) || pattern . test ( prevToken . value ) ) &&
! isCloseParenOfTemplate ( nextToken ) && ! isOpenParenOfTemplate ( prevToken ) &&
astUtils . isTokenOnSameLine ( token , nextToken ) && astUtils . isTokenOnSameLine ( prevToken , token ) &&
! sourceCode . isSpaceBetweenTokens ( token , nextToken ) sourceCode . isSpaceBetweenTokens ( prevToken , token )
) { ) {
context . report ( { context . report ( {
loc : token . loc . start , loc : token . loc . start ,
message : "Expected space(s) after \"{{value}}\"." , message : "Unexpected space(s) before \"{{value}}\"." ,
data : token , data : token ,
fix : function ( fixer ) { fix : function ( fixer ) {
return fixer . insertTextAfter ( token , " " ) ; return fixer . removeRange ( [ prevToken . range [ 1 ] , token . range [ 0 ] ] ) ;
} }
} ) ; } ) ;
}
} }
}
/ * * / * *
* Reports a given token if there are space ( s ) after the token . * Reports a given token if there are not space ( s ) after the token .
* *
* @ param { Token } token - A token to report . * @ param { Token } token - A token to report .
* @ param { RegExp | undefined } pattern - Optional . A pattern of the next * @ param { RegExp | undefined } pattern - Optional . A pattern of the next
* token to check . * token to check .
* @ returns { void } * @ returns { void }
* / * /
function unexpectSpaceAfter ( token , pattern ) { function expectSpaceAfter ( token , pattern ) {
pattern = pattern || NEXT_TOKEN ; pattern = pattern || NEXT_TOKEN ;
var nextToken = sourceCode . getTokenAfter ( token ) ; var nextToken = sourceCode . getTokenAfter ( token ) ;
if ( nextToken && if ( nextToken &&
( CHECK_TYPE . test ( nextToken . type ) || pattern . test ( nextToken . value ) ) && ( CHECK_TYPE . test ( nextToken . type ) || pattern . test ( nextToken . value ) ) &&
! isCloseParenOfTemplate ( nextToken ) && ! isCloseParenOfTemplate ( nextToken ) &&
astUtils . isTokenOnSameLine ( token , nextToken ) && astUtils . isTokenOnSameLine ( token , nextToken ) &&
sourceCode . isSpaceBetweenTokens ( token , nextToken ) ! sourceCode . isSpaceBetweenTokens ( token , nextToken )
) { ) {
context . report ( { context . report ( {
loc : token . loc . start , loc : token . loc . start ,
message : "Unexpected space(s) after \"{{value}}\"." , message : "Expected space(s) after \"{{value}}\"." ,
data : token , data : token ,
fix : function ( fixer ) { fix : function ( fixer ) {
return fixer . removeRange ( [ token . range [ 1 ] , nextToken . range [ 0 ] ] ) ; return fixer . insertTextAfter ( token , " " ) ;
} }
} ) ; } ) ;
}
} }
}
/ * * / * *
* Parses the option object and determines check methods for each keyword . * Reports a given token if there are space ( s ) after the token .
* *
* @ param { object | undefined } options - The option object to parse . * @ param { Token } token - A token to report .
* @ returns { object } - Normalized option object . * @ param { RegExp | undefined } pattern - Optional . A pattern of the next
* Keys are keywords ( there are for every keyword ) . * token to check .
* Values are instances of ` {"before": function, "after": function} ` . * @ returns { void }
* / * /
function parseOptions ( options ) { function unexpectSpaceAfter ( token , pattern ) {
var before = ! options || options . before !== false ; pattern = pattern || NEXT_TOKEN ;
var after = ! options || options . after !== false ;
var defaultValue = { var nextToken = sourceCode . getTokenAfter ( token ) ;
before : before ? expectSpaceBefore : unexpectSpaceBefore ,
after : after ? expectSpaceAfter : unexpectSpaceAfter if ( nextToken &&
} ; ( CHECK_TYPE . test ( nextToken . type ) || pattern . test ( nextToken . value ) ) &&
var overrides = ( options && options . overrides ) || { } ; ! isCloseParenOfTemplate ( nextToken ) &&
var retv = Object . create ( null ) ; astUtils . isTokenOnSameLine ( token , nextToken ) &&
sourceCode . isSpaceBetweenTokens ( token , nextToken )
for ( var i = 0 ; i < KEYS . length ; ++ i ) { ) {
var key = KEYS [ i ] ; context . report ( {
var override = overrides [ key ] ; loc : token . loc . start ,
message : "Unexpected space(s) after \"{{value}}\"." ,
if ( override ) { data : token ,
var thisBefore = ( "before" in override ) ? override . before : before ; fix : function ( fixer ) {
var thisAfter = ( "after" in override ) ? override . after : after ; return fixer . removeRange ( [ token . range [ 1 ] , nextToken . range [ 0 ] ] ) ;
}
retv [ key ] = { } ) ;
before : thisBefore ? expectSpaceBefore : unexpectSpaceBefore ,
after : thisAfter ? expectSpaceAfter : unexpectSpaceAfter
} ;
} else {
retv [ key ] = defaultValue ;
} }
} }
return retv ; / * *
} * Parses the option object and determines check methods for each keyword .
*
* @ param { object | undefined } options - The option object to parse .
* @ returns { object } - Normalized option object .
* Keys are keywords ( there are for every keyword ) .
* Values are instances of ` {"before": function, "after": function} ` .
* /
function parseOptions ( options ) {
var before = ! options || options . before !== false ;
var after = ! options || options . after !== false ;
var defaultValue = {
before : before ? expectSpaceBefore : unexpectSpaceBefore ,
after : after ? expectSpaceAfter : unexpectSpaceAfter
} ;
var overrides = ( options && options . overrides ) || { } ;
var retv = Object . create ( null ) ;
for ( var i = 0 ; i < KEYS . length ; ++ i ) {
var key = KEYS [ i ] ;
var override = overrides [ key ] ;
if ( override ) {
var thisBefore = ( "before" in override ) ? override . before : before ;
var thisAfter = ( "after" in override ) ? override . after : after ;
var checkMethodMap = parseOptions ( context . options [ 0 ] ) ; retv [ key ] = {
before : thisBefore ? expectSpaceBefore : unexpectSpaceBefore ,
/ * * after : thisAfter ? expectSpaceAfter : unexpectSpaceAfter
* Reports a given token if usage of spacing followed by the token is } ;
* invalid . } else {
* retv [ key ] = defaultValue ;
* @ param { Token } token - A token to report . }
* @ param { RegExp | undefined } pattern - Optional . A pattern of the previous }
* token to check .
* @ returns { void }
* /
function checkSpacingBefore ( token , pattern ) {
checkMethodMap [ token . value ] . before ( token , pattern ) ;
}
/ * * return retv ;
* Reports a given token if usage of spacing preceded by the token is }
* invalid .
*
* @ param { Token } token - A token to report .
* @ param { RegExp | undefined } pattern - Optional . A pattern of the next
* token to check .
* @ returns { void }
* /
function checkSpacingAfter ( token , pattern ) {
checkMethodMap [ token . value ] . after ( token , pattern ) ;
}
/ * * var checkMethodMap = parseOptions ( context . options [ 0 ] ) ;
* Reports a given token if usage of spacing around the token is invalid .
* / * *
* @ param { Token } token - A token to report . * Reports a given token if usage of spacing followed by the token is
* @ returns { void } * invalid .
* / *
function checkSpacingAround ( token ) { * @ param { Token } token - A token to report .
checkSpacingBefore ( token ) ; * @ param { RegExp | undefined } pattern - Optional . A pattern of the previous
checkSpacingAfter ( token ) ; * token to check .
} * @ returns { void }
* /
function checkSpacingBefore ( token , pattern ) {
checkMethodMap [ token . value ] . before ( token , pattern ) ;
}
/ * * / * *
* Reports the first token of a given node if the first token is a keyword * Reports a given token if usage of spacing preceded by the token is
* and usage of spacing around the token is invalid . * invalid .
* *
* @ param { ASTNode | null } node - A node to report . * @ param { Token } token - A token to report .
* @ returns { void } * @ param { RegExp | undefined } pattern - Optional . A pattern of the next
* / * token to check .
function checkSpacingAroundFirstToken ( node ) { * @ returns { void }
var firstToken = node && sourceCode . getFirstToken ( node ) ; * /
function checkSpacingAfter ( token , pattern ) {
if ( firstToken && firstToken . type === "Keyword" ) { checkMethodMap [ token . value ] . after ( token , pattern ) ;
checkSpacingAround ( firstToken ) ;
} }
}
/ * * / * *
* Reports the first token of a given node if the first token is a keyword * Reports a given token if usage of spacing around the token is invalid .
* and usage of spacing followed by the token is invalid . *
* * @ param { Token } token - A token to report .
* This is used for unary operators ( e . g . ` typeof ` ) , ` function ` , and ` super ` . * @ returns { void }
* Other rules are handling usage of spacing preceded by those keywords . * /
* function checkSpacingAround ( token ) {
* @ param { ASTNode | null } node - A node to report . checkSpacingBefore ( token ) ;
* @ returns { void } checkSpacingAfter ( token ) ;
* /
function checkSpacingBeforeFirstToken ( node ) {
var firstToken = node && sourceCode . getFirstToken ( node ) ;
if ( firstToken && firstToken . type === "Keyword" ) {
checkSpacingBefore ( firstToken ) ;
} }
}
/ * * / * *
* Reports the previous token of a given node if the token is a keyword and * Reports the first token of a given node if the first token is a keyword
* usage of spacing around the token is invalid . * and usage of spacing around the token is invalid .
* *
* @ param { ASTNode | null } node - A node to report . * @ param { ASTNode | null } node - A node to report .
* @ returns { void } * @ returns { void }
* / * /
function checkSpacingAroundTokenBefore ( node ) { function checkSpacingAroundFirstToken ( node ) {
if ( node ) { var firstToken = node && sourceCode . getFirstToken ( node ) ;
var token = sourceCode . getTokenBefore ( node ) ;
if ( firstToken && firstToken . type === "Keyword" ) {
while ( token . type !== "Keyword" ) { checkSpacingAround ( firstToken ) ;
token = sourceCode . getTokenBefore ( token ) ;
} }
checkSpacingAround ( token ) ;
} }
}
/ * * / * *
* Reports ` class ` and ` extends ` keywords of a given node if usage of * Reports the first token of a given node if the first token is a keyword
* spacing around those keywords is invalid . * and usage of spacing followed by the token is invalid .
* *
* @ param { ASTNode } node - A node to report . * This is used for unary operators ( e . g . ` typeof ` ) , ` function ` , and ` super ` .
* @ returns { void } * Other rules are handling usage of spacing preceded by those keywords .
* / *
function checkSpacingForClass ( node ) { * @ param { ASTNode | null } node - A node to report .
checkSpacingAroundFirstToken ( node ) ; * @ returns { void }
checkSpacingAroundTokenBefore ( node . superClass ) ; * /
} function checkSpacingBeforeFirstToken ( node ) {
var firstToken = node && sourceCode . getFirstToken ( node ) ;
/ * *
* Reports ` if ` and ` else ` keywords of a given node if usage of spacing if ( firstToken && firstToken . type === "Keyword" ) {
* around those keywords is invalid . checkSpacingBefore ( firstToken ) ;
* }
* @ param { ASTNode } node - A node to report . }
* @ returns { void }
* /
function checkSpacingForIfStatement ( node ) {
checkSpacingAroundFirstToken ( node ) ;
checkSpacingAroundTokenBefore ( node . alternate ) ;
}
/ * * / * *
* Reports ` try ` , ` catch ` , and ` finally ` keywords of a given node if usage * Reports the previous token of a given node if the token is a keyword and
* of spacing around those keywords is invalid . * usage of spacing around the token is invalid .
* *
* @ param { ASTNode } node - A node to report . * @ param { ASTNode | null } node - A node to report .
* @ returns { void } * @ returns { void }
* / * /
function checkSpacingForTryStatement ( node ) { function checkSpacingAroundTokenBefore ( node ) {
checkSpacingAroundFirstToken ( node ) ; if ( node ) {
checkSpacingAroundFirstToken ( node . handler ) ; var token = sourceCode . getTokenBefore ( node ) ;
checkSpacingAroundTokenBefore ( node . finalizer ) ;
} while ( token . type !== "Keyword" ) {
token = sourceCode . getTokenBefore ( token ) ;
}
/ * * checkSpacingAround ( token ) ;
* Reports ` do ` and ` while ` keywords of a given node if usage of spacing }
* around those keywords is invalid . }
*
* @ param { ASTNode } node - A node to report .
* @ returns { void }
* /
function checkSpacingForDoWhileStatement ( node ) {
checkSpacingAroundFirstToken ( node ) ;
checkSpacingAroundTokenBefore ( node . test ) ;
}
/ * * / * *
* Reports ` for ` and ` in ` keywords of a given node if usage of spacing * Reports ` class ` and ` extends ` keywords of a given node if usage of
* around those keywords is invalid . * spacing around those keywords is invalid .
* *
* @ param { ASTNode } node - A node to report . * @ param { ASTNode } node - A node to report .
* @ returns { void } * @ returns { void }
* / * /
function checkSpacingForForInStatement ( node ) { function checkSpacingForClass ( node ) {
checkSpacingAroundFirstToken ( node ) ; checkSpacingAroundFirstToken ( node ) ;
checkSpacingAroundTokenBefore ( node . right ) ; checkSpacingAroundTokenBefore ( node . superClass ) ;
} }
/ * * / * *
* Reports ` for ` and ` of ` keywords of a given node if usage of spacing * Reports ` if ` and ` else ` keywords of a given node if usage of spacing
* around those keywords is invalid . * around those keywords is invalid .
* *
* @ param { ASTNode } node - A node to report . * @ param { ASTNode } node - A node to report .
* @ returns { void } * @ returns { void }
* / * /
function checkSpacingForForOfStatement ( node ) { function checkSpacingForIfStatement ( node ) {
checkSpacingAroundFirstToken ( node ) ; checkSpacingAroundFirstToken ( node ) ;
checkSpacingAroundTokenBefore ( node . alternate ) ;
// `of` is not a keyword token.
var token = sourceCode . getTokenBefore ( node . right ) ;
while ( token . value !== "of" ) {
token = sourceCode . getTokenBefore ( token ) ;
} }
checkSpacingAround ( token ) ;
}
/ * * / * *
* Reports ` import ` , ` export ` , ` as ` , and ` from ` keywords of a given node if * Reports ` try ` , ` catch ` , and ` finally ` keywords of a given node if usage
* usage of spacing around those keywords is invalid . * of spacing around those keywords is invalid .
* *
* This rule handles the ` * ` token in module declarations . * @ param { ASTNode } node - A node to report .
* * @ returns { void }
* import * as A from "./a" ; / * e r r o r E x p e c t e d s p a c e ( s ) a f t e r " i m p o r t " . * /
* error Expected space ( s ) before "as" . function checkSpacingForTryStatement ( node ) {
* checkSpacingAroundFirstToken ( node ) ;
* @ param { ASTNode } node - A node to report . checkSpacingAroundFirstToken ( node . handler ) ;
* @ returns { void } checkSpacingAroundTokenBefore ( node . finalizer ) ;
* /
function checkSpacingForModuleDeclaration ( node ) {
var firstToken = sourceCode . getFirstToken ( node ) ;
checkSpacingBefore ( firstToken , PREV_TOKEN_M ) ;
checkSpacingAfter ( firstToken , NEXT_TOKEN_M ) ;
if ( node . source ) {
var fromToken = sourceCode . getTokenBefore ( node . source ) ;
checkSpacingBefore ( fromToken , PREV_TOKEN_M ) ;
checkSpacingAfter ( fromToken , NEXT_TOKEN_M ) ;
} }
}
/ * * / * *
* Reports ` as ` keyword of a given node if usage of spacing around this * Reports ` do ` and ` while ` keywords of a given node if usage of spacing
* keyword is invalid . * around those keywords is invalid .
* *
* @ param { ASTNode } node - A node to report . * @ param { ASTNode } node - A node to report .
* @ returns { void } * @ returns { void }
* / * /
function checkSpacingForImportNamespaceSpecifier ( node ) { function checkSpacingForDoWhileStatement ( node ) {
var asToken = sourceCode . getFirstToken ( node , 1 ) ; checkSpacingAroundFirstToken ( node ) ;
checkSpacingAroundTokenBefore ( node . test ) ;
checkSpacingBefore ( asToken , PREV_TOKEN_M ) ; }
}
/ * * / * *
* Reports ` static ` , ` get ` , and ` set ` keywords of a given node if usage of * Reports ` for ` and ` in ` keywords of a given node if usage of spacing
* spacing around those keywords is invalid . * around those keywords is invalid .
* *
* @ param { ASTNode } node - A node to report . * @ param { ASTNode } node - A node to report .
* @ returns { void } * @ returns { void }
* / * /
function checkSpacingForProperty ( node ) { function checkSpacingForForInStatement ( node ) {
if ( node . static ) {
checkSpacingAroundFirstToken ( node ) ; checkSpacingAroundFirstToken ( node ) ;
checkSpacingAroundTokenBefore ( node . right ) ;
} }
if ( node . kind === "get" || node . kind === "set" ) {
var token = sourceCode . getFirstToken (
node ,
node . static ? 1 : 0
) ;
/ * *
* Reports ` for ` and ` of ` keywords of a given node if usage of spacing
* around those keywords is invalid .
*
* @ param { ASTNode } node - A node to report .
* @ returns { void }
* /
function checkSpacingForForOfStatement ( node ) {
checkSpacingAroundFirstToken ( node ) ;
// `of` is not a keyword token.
var token = sourceCode . getTokenBefore ( node . right ) ;
while ( token . value !== "of" ) {
token = sourceCode . getTokenBefore ( token ) ;
}
checkSpacingAround ( token ) ; checkSpacingAround ( token ) ;
} }
}
return { / * *
* Reports ` import ` , ` export ` , ` as ` , and ` from ` keywords of a given node if
// Statements
* usage of spacing around those keywords is invalid .
DebuggerStatement : checkSpacingAroundFirstToken , *
WithStatement : checkSpacingAroundFirstToken , * This rule handles the ` * ` token in module declarations .
*
// Statements - Control flow
* import * as A from "./a" ; / * e r r o r E x p e c t e d s p a c e ( s ) a f t e r " i m p o r t " .
BreakStatement : checkSpacingAroundFirstToken , * error Expected space ( s ) before "as" .
ContinueStatement : checkSpacingAroundFirstToken , *
ReturnStatement : checkSpacingAroundFirstToken , * @ param { ASTNode } node - A node to report .
ThrowStatement : checkSpacingAroundFirstToken , * @ returns { void }
TryStatement : checkSpacingForTryStatement , * /
function checkSpacingForModuleDeclaration ( node ) {
// Statements - Choice
var firstToken = sourceCode . getFirstToken ( node ) ;
IfStatement : checkSpacingForIfStatement ,
SwitchStatement : checkSpacingAroundFirstToken , checkSpacingBefore ( firstToken , PREV_TOKEN_M ) ;
SwitchCase : checkSpacingAroundFirstToken , checkSpacingAfter ( firstToken , NEXT_TOKEN_M ) ;
// Statements - Loops
if ( node . source ) {
DoWhileStatement : checkSpacingForDoWhileStatement , var fromToken = sourceCode . getTokenBefore ( node . source ) ;
ForInStatement : checkSpacingForForInStatement ,
ForOfStatement : checkSpacingForForOfStatement , checkSpacingBefore ( fromToken , PREV_TOKEN_M ) ;
ForStatement : checkSpacingAroundFirstToken , checkSpacingAfter ( fromToken , NEXT_TOKEN_M ) ;
WhileStatement : checkSpacingAroundFirstToken , }
}
// Statements - Declarations
ClassDeclaration : checkSpacingForClass ,
ExportNamedDeclaration : checkSpacingForModuleDeclaration ,
ExportDefaultDeclaration : checkSpacingAroundFirstToken ,
ExportAllDeclaration : checkSpacingForModuleDeclaration ,
FunctionDeclaration : checkSpacingBeforeFirstToken ,
ImportDeclaration : checkSpacingForModuleDeclaration ,
VariableDeclaration : checkSpacingAroundFirstToken ,
// Expressions
ClassExpression : checkSpacingForClass ,
FunctionExpression : checkSpacingBeforeFirstToken ,
NewExpression : checkSpacingBeforeFirstToken ,
Super : checkSpacingBeforeFirstToken ,
ThisExpression : checkSpacingBeforeFirstToken ,
UnaryExpression : checkSpacingBeforeFirstToken ,
YieldExpression : checkSpacingBeforeFirstToken ,
// Others
ImportNamespaceSpecifier : checkSpacingForImportNamespaceSpecifier ,
MethodDefinition : checkSpacingForProperty ,
Property : checkSpacingForProperty
} ;
} ;
module . exports . schema = [ / * *
{ * Reports ` as ` keyword of a given node if usage of spacing around this
"type" : "object" , * keyword is invalid .
"properties" : { *
"before" : { "type" : "boolean" } , * @ param { ASTNode } node - A node to report .
"after" : { "type" : "boolean" } , * @ returns { void }
"overrides" : { * /
"type" : "object" , function checkSpacingForImportNamespaceSpecifier ( node ) {
"properties" : KEYS . reduce ( function ( retv , key ) { var asToken = sourceCode . getFirstToken ( node , 1 ) ;
retv [ key ] = {
"type" : "object" , checkSpacingBefore ( asToken , PREV_TOKEN_M ) ;
"properties" : { }
"before" : { "type" : "boolean" } ,
"after" : { "type" : "boolean" } / * *
} , * Reports ` static ` , ` get ` , and ` set ` keywords of a given node if usage of
"additionalProperties" : false * spacing around those keywords is invalid .
} ; *
return retv ; * @ param { ASTNode } node - A node to report .
} , { } ) , * @ returns { void }
"additionalProperties" : false * /
function checkSpacingForProperty ( node ) {
if ( node . static ) {
checkSpacingAroundFirstToken ( node ) ;
} }
} , if ( node . kind === "get" || node . kind === "set" ) {
"additionalProperties" : false var token = sourceCode . getFirstToken (
node ,
node . static ? 1 : 0
) ;
checkSpacingAround ( token ) ;
}
}
return {
// Statements
DebuggerStatement : checkSpacingAroundFirstToken ,
WithStatement : checkSpacingAroundFirstToken ,
// Statements - Control flow
BreakStatement : checkSpacingAroundFirstToken ,
ContinueStatement : checkSpacingAroundFirstToken ,
ReturnStatement : checkSpacingAroundFirstToken ,
ThrowStatement : checkSpacingAroundFirstToken ,
TryStatement : checkSpacingForTryStatement ,
// Statements - Choice
IfStatement : checkSpacingForIfStatement ,
SwitchStatement : checkSpacingAroundFirstToken ,
SwitchCase : checkSpacingAroundFirstToken ,
// Statements - Loops
DoWhileStatement : checkSpacingForDoWhileStatement ,
ForInStatement : checkSpacingForForInStatement ,
ForOfStatement : checkSpacingForForOfStatement ,
ForStatement : checkSpacingAroundFirstToken ,
WhileStatement : checkSpacingAroundFirstToken ,
// Statements - Declarations
ClassDeclaration : checkSpacingForClass ,
ExportNamedDeclaration : checkSpacingForModuleDeclaration ,
ExportDefaultDeclaration : checkSpacingAroundFirstToken ,
ExportAllDeclaration : checkSpacingForModuleDeclaration ,
FunctionDeclaration : checkSpacingBeforeFirstToken ,
ImportDeclaration : checkSpacingForModuleDeclaration ,
VariableDeclaration : checkSpacingAroundFirstToken ,
// Expressions
ClassExpression : checkSpacingForClass ,
FunctionExpression : checkSpacingBeforeFirstToken ,
NewExpression : checkSpacingBeforeFirstToken ,
Super : checkSpacingBeforeFirstToken ,
ThisExpression : checkSpacingBeforeFirstToken ,
UnaryExpression : checkSpacingBeforeFirstToken ,
YieldExpression : checkSpacingBeforeFirstToken ,
// Others
ImportNamespaceSpecifier : checkSpacingForImportNamespaceSpecifier ,
MethodDefinition : checkSpacingForProperty ,
Property : checkSpacingForProperty
} ;
} }
] ; } ;
Rich Trott
9 years ago
Evan Lucas