Skip to content

Commit

Permalink
Incorporate feedback :)
Browse files Browse the repository at this point in the history
  • Loading branch information
@kaicataldo
kaicataldo committed Oct 26, 2019
1 parent 95cefe7 commit a3fd4fc
Show file tree
Hide file tree
Showing 2 changed files with 187 additions and 178 deletions.
5 changes: 3 additions & 2 deletions lib/source-code/source-code.js
View file
Expand Up @@ -420,12 +420,13 @@ class SourceCode extends TokenStore {
* @public
*/
isSpaceBetweenTokens(first, second) {
const finalToken = this.getFirstToken(second) || second;
let currentToken = this.getLastToken(first) || first;

while (currentToken !== (this.getFirstToken(second) || second)) {
while (currentToken !== finalToken) {
const nextToken = this.getTokenAfter(currentToken, { includeComments: true });

if (/\s/u.test(this.text.slice(currentToken.range[1], nextToken.range[0]))) {
if (currentToken.range[1] !== nextToken.range[0]) {
return true;
}

Expand Down
360 changes: 184 additions & 176 deletions tests/lib/source-code/source-code.js
View file
Expand Up @@ -1790,193 +1790,201 @@ describe("SourceCode", () => {
});

describe("isSpaceBetweenTokens()", () => {
leche.withData([
["let foo", true],
["let foo", true],
["let /**/ foo", true],
["let/**/foo", false],
["let/*\n*/foo", false]
], (code, expected) => {
it("should return true when there is at least one whitespace character between two tokens", () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.tokens[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1]
),
expected
);
describe("should return true when there is at least one whitespace character between two tokens", () => {
leche.withData([
["let foo", true],
["let foo", true],
["let /**/ foo", true],
["let/**/foo", false],
["let/*\n*/foo", false]
], (code, expected) => {
it(code, () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.tokens[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1]
),
expected
);
});
});
});

leche.withData([
["a+b", false],
["a +b", true],
["a/**/+b", false],
["a/* */+b", false],
["a/**/ +b", true],
["a/**/ /**/+b", true],
["a/* */ /* */+b", true],
["a/**/\n/**/+b", true],
["a/* */\n/* */+b", true],
["a/**/+b/**/+c", false],
["a/* */+b/* */+c", false],
["a/**/+b /**/+c", true],
["a/* */+b /* */+c", true],
["a/**/ +b/**/+c", true],
["a/* */ +b/* */+c", true],
["a/**/+b\t/**/+c", true],
["a/* */+b\t/* */+c", true],
["a/**/\t+b/**/+c", true],
["a/* */\t+b/* */+c", true],
["a/**/+b\n/**/+c", true],
["a/* */+b\n/* */+c", true],
["a/**/\n+b/**/+c", true],
["a/* */\n+b/* */+c", true],
["a/* */+' /**/ '/* */+c", false],
["a/* */+ ' /**/ '/* */+c", true],
["a/* */+' /**/ ' /* */+c", true],
["a/* */+ ' /**/ ' /* */+c", true],
["a/* */+` /*\n*/ `/* */+c", false],
["a/* */+ ` /*\n*/ `/* */+c", true],
["a/* */+` /*\n*/ ` /* */+c", true],
["a/* */+ ` /*\n*/ ` /* */+c", true]
], (code, expected) => {
it("should return true when there is at least one whitespace character between two tokens", () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.tokens[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 2]
),
expected
);
leche.withData([
["a+b", false],
["a +b", true],
["a/**/+b", false],
["a/* */+b", false],
["a/**/ +b", true],
["a/**/ /**/+b", true],
["a/* */ /* */+b", true],
["a/**/\n/**/+b", true],
["a/* */\n/* */+b", true],
["a/**/+b/**/+c", false],
["a/* */+b/* */+c", false],
["a/**/+b /**/+c", true],
["a/* */+b /* */+c", true],
["a/**/ +b/**/+c", true],
["a/* */ +b/* */+c", true],
["a/**/+b\t/**/+c", true],
["a/* */+b\t/* */+c", true],
["a/**/\t+b/**/+c", true],
["a/* */\t+b/* */+c", true],
["a/**/+b\n/**/+c", true],
["a/* */+b\n/* */+c", true],
["a/**/\n+b/**/+c", true],
["a/* */\n+b/* */+c", true],
["a/* */+' /**/ '/* */+c", false],
["a/* */+ ' /**/ '/* */+c", true],
["a/* */+' /**/ ' /* */+c", true],
["a/* */+ ' /**/ ' /* */+c", true],
["a/* */+` /*\n*/ `/* */+c", false],
["a/* */+ ` /*\n*/ `/* */+c", true],
["a/* */+` /*\n*/ ` /* */+c", true],
["a/* */+ ` /*\n*/ ` /* */+c", true]
], (code, expected) => {
it(code, () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.tokens[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 2]
),
expected
);
});
});
});

leche.withData([
[";let foo = bar", false],
[";/**/let foo = bar", false],
[";/* */let foo = bar", false],
["; let foo = bar", true],
["; let foo = bar", true],
["; /**/let foo = bar", true],
["; /* */let foo = bar", true],
[";/**/ let foo = bar", true],
[";/* */ let foo = bar", true],
["; /**/ let foo = bar", true],
["; /* */ let foo = bar", true],
[";\tlet foo = bar", true],
[";\tlet foo = bar", true],
[";\t/**/let foo = bar", true],
[";\t/* */let foo = bar", true],
[";/**/\tlet foo = bar", true],
[";/* */\tlet foo = bar", true],
[";\t/**/\tlet foo = bar", true],
[";\t/* */\tlet foo = bar", true],
[";\nlet foo = bar", true],
[";\nlet foo = bar", true],
[";\n/**/let foo = bar", true],
[";\n/* */let foo = bar", true],
[";/**/\nlet foo = bar", true],
[";/* */\nlet foo = bar", true],
[";\n/**/\nlet foo = bar", true],
[";\n/* */\nlet foo = bar", true]
], (code, expected) => {
it("should return true when there is at least one whitespace character between a token and a node", () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.tokens[0], sourceCode.ast.body[sourceCode.ast.body.length - 1]
),
expected
);
describe("should return true when there is at least one whitespace character between a token and a node", () => {
leche.withData([
[";let foo = bar", false],
[";/**/let foo = bar", false],
[";/* */let foo = bar", false],
["; let foo = bar", true],
["; let foo = bar", true],
["; /**/let foo = bar", true],
["; /* */let foo = bar", true],
[";/**/ let foo = bar", true],
[";/* */ let foo = bar", true],
["; /**/ let foo = bar", true],
["; /* */ let foo = bar", true],
[";\tlet foo = bar", true],
[";\tlet foo = bar", true],
[";\t/**/let foo = bar", true],
[";\t/* */let foo = bar", true],
[";/**/\tlet foo = bar", true],
[";/* */\tlet foo = bar", true],
[";\t/**/\tlet foo = bar", true],
[";\t/* */\tlet foo = bar", true],
[";\nlet foo = bar", true],
[";\nlet foo = bar", true],
[";\n/**/let foo = bar", true],
[";\n/* */let foo = bar", true],
[";/**/\nlet foo = bar", true],
[";/* */\nlet foo = bar", true],
[";\n/**/\nlet foo = bar", true],
[";\n/* */\nlet foo = bar", true]
], (code, expected) => {
it(code, () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.tokens[0], sourceCode.ast.body[sourceCode.ast.body.length - 1]
),
expected
);
});
});
});

leche.withData([
["let foo = bar;;", false],
["let foo = bar;;;", false],
["let foo = 1; let bar = 2;;", true],
["let foo = bar;/**/;", false],
["let foo = bar;/* */;", false],
["let foo = bar;;;", false],
["let foo = bar; ;", true],
["let foo = bar; /**/;", true],
["let foo = bar; /* */;", true],
["let foo = bar;/**/ ;", true],
["let foo = bar;/* */ ;", true],
["let foo = bar; /**/ ;", true],
["let foo = bar; /* */ ;", true],
["let foo = bar;\t;", true],
["let foo = bar;\t/**/;", true],
["let foo = bar;\t/* */;", true],
["let foo = bar;/**/\t;", true],
["let foo = bar;/* */\t;", true],
["let foo = bar;\t/**/\t;", true],
["let foo = bar;\t/* */\t;", true],
["let foo = bar;\n;", true],
["let foo = bar;\n/**/;", true],
["let foo = bar;\n/* */;", true],
["let foo = bar;/**/\n;", true],
["let foo = bar;/* */\n;", true],
["let foo = bar;\n/**/\n;", true],
["let foo = bar;\n/* */\n;", true]
], (code, expected) => {
it("should return true when there is at least one whitespace character between a node and a token", () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.body[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1]
),
expected
);
describe("should return true when there is at least one whitespace character between a node and a token", () => {
leche.withData([
["let foo = bar;;", false],
["let foo = bar;;;", false],
["let foo = 1; let bar = 2;;", true],
["let foo = bar;/**/;", false],
["let foo = bar;/* */;", false],
["let foo = bar;;;", false],
["let foo = bar; ;", true],
["let foo = bar; /**/;", true],
["let foo = bar; /* */;", true],
["let foo = bar;/**/ ;", true],
["let foo = bar;/* */ ;", true],
["let foo = bar; /**/ ;", true],
["let foo = bar; /* */ ;", true],
["let foo = bar;\t;", true],
["let foo = bar;\t/**/;", true],
["let foo = bar;\t/* */;", true],
["let foo = bar;/**/\t;", true],
["let foo = bar;/* */\t;", true],
["let foo = bar;\t/**/\t;", true],
["let foo = bar;\t/* */\t;", true],
["let foo = bar;\n;", true],
["let foo = bar;\n/**/;", true],
["let foo = bar;\n/* */;", true],
["let foo = bar;/**/\n;", true],
["let foo = bar;/* */\n;", true],
["let foo = bar;\n/**/\n;", true],
["let foo = bar;\n/* */\n;", true]
], (code, expected) => {
it(code, () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.body[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1]
),
expected
);
});
});
});

leche.withData([
["let foo = bar;let baz = qux;", false],
["let foo = bar;/**/let baz = qux;", false],
["let foo = bar;/* */let baz = qux;", false],
["let foo = bar; let baz = qux;", true],
["let foo = bar; /**/let baz = qux;", true],
["let foo = bar; /* */let baz = qux;", true],
["let foo = bar;/**/ let baz = qux;", true],
["let foo = bar;/* */ let baz = qux;", true],
["let foo = bar; /**/ let baz = qux;", true],
["let foo = bar; /* */ let baz = qux;", true],
["let foo = bar;\tlet baz = qux;", true],
["let foo = bar;\t/**/let baz = qux;", true],
["let foo = bar;\t/* */let baz = qux;", true],
["let foo = bar;/**/\tlet baz = qux;", true],
["let foo = bar;/* */\tlet baz = qux;", true],
["let foo = bar;\t/**/\tlet baz = qux;", true],
["let foo = bar;\t/* */\tlet baz = qux;", true],
["let foo = bar;\nlet baz = qux;", true],
["let foo = bar;\n/**/let baz = qux;", true],
["let foo = bar;\n/* */let baz = qux;", true],
["let foo = bar;/**/\nlet baz = qux;", true],
["let foo = bar;/* */\nlet baz = qux;", true],
["let foo = bar;\n/**/\nlet baz = qux;", true],
["let foo = bar;\n/* */\nlet baz = qux;", true],
["let foo = 1;let foo2 = 2; let foo3 = 3;", true]
], (code, expected) => {
it("should return true when there is at least one whitespace character between two nodes", () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.body[0], sourceCode.ast.body[sourceCode.ast.body.length - 1]
),
expected
);
describe("should return true when there is at least one whitespace character between two nodes", () => {
leche.withData([
["let foo = bar;let baz = qux;", false],
["let foo = bar;/**/let baz = qux;", false],
["let foo = bar;/* */let baz = qux;", false],
["let foo = bar; let baz = qux;", true],
["let foo = bar; /**/let baz = qux;", true],
["let foo = bar; /* */let baz = qux;", true],
["let foo = bar;/**/ let baz = qux;", true],
["let foo = bar;/* */ let baz = qux;", true],
["let foo = bar; /**/ let baz = qux;", true],
["let foo = bar; /* */ let baz = qux;", true],
["let foo = bar;\tlet baz = qux;", true],
["let foo = bar;\t/**/let baz = qux;", true],
["let foo = bar;\t/* */let baz = qux;", true],
["let foo = bar;/**/\tlet baz = qux;", true],
["let foo = bar;/* */\tlet baz = qux;", true],
["let foo = bar;\t/**/\tlet baz = qux;", true],
["let foo = bar;\t/* */\tlet baz = qux;", true],
["let foo = bar;\nlet baz = qux;", true],
["let foo = bar;\n/**/let baz = qux;", true],
["let foo = bar;\n/* */let baz = qux;", true],
["let foo = bar;/**/\nlet baz = qux;", true],
["let foo = bar;/* */\nlet baz = qux;", true],
["let foo = bar;\n/**/\nlet baz = qux;", true],
["let foo = bar;\n/* */\nlet baz = qux;", true],
["let foo = 1;let foo2 = 2; let foo3 = 3;", true]
], (code, expected) => {
it(code, () => {
const ast = espree.parse(code, DEFAULT_CONFIG),
sourceCode = new SourceCode(code, ast);

assert.strictEqual(
sourceCode.isSpaceBetweenTokens(
sourceCode.ast.body[0], sourceCode.ast.body[sourceCode.ast.body.length - 1]
),
expected
);
});
});
});
});
Expand Down

0 comments on commit a3fd4fc

Please sign in to comment.