ESLint passing

Author: MitMaro

.eslintrc

@@ -8,8 +8,8 @@ rules:
     no-constant-condition:
         - error
         - checkLoops: false
-    newline-after-var: off
     no-extra-parens:
         - error
         - all
         - nestedBinaryExpressions: false
+    no-undefined: off

src/Lexer.js

@@ -170,7 +170,6 @@ class Lexer {
 		return false;
 	}
 
-
 	// scan up to the next delimiter
 	scanToNextDelimiter() {
 		// if already at delimiter
@@ -190,16 +189,20 @@ class Lexer {
 	// scan pass the next delimiter
 	scanNextDelimiter() {
 		const delimiter = this.isAtDelimiter() || '';
+
 		this.pointer = this.pointer + delimiter.length;
 	}
 
 	*tokens() {
 		while (this.pointer < this.input.length) {
 			if (this.state === STATE_TEXT_LITERAL) {
 				const startIndex = this.pointer;
+
 				this.scanTextLiteral();
 				this.state = STATE_TAG;
+
 				const value = this.input.substring(startIndex, this.pointer);
+
 				if (!value.length) {
 					continue;
 				}
@@ -213,12 +216,15 @@ class Lexer {
 			}
 			else if (this.state === STATE_TAG || this.state === STATE_END_STRING) {
 				let type;
+
 				this.skipWhitespace();
+
 				let startIndex = this.pointer;
 
 				// scan until next delimiter
 				this.scanToNextDelimiter();
 				let value = this.input.substring(startIndex, this.pointer);
+
 				if (value.length) {
 					type = statementTypeLookup[value];
 					if (type) {
@@ -300,6 +306,7 @@ class Lexer {
 			}
 			else if (this.state === STATE_STRING) {
 				const startIndex = this.pointer;
+
 				this.scanString();
 				this.state = STATE_END_STRING;
 				yield {

src/Parser.js

@@ -4,7 +4,6 @@ const ParserError = require('./error/Parser');
 
 const {
 	TOKEN_TYPE_VALUE,
-	TOKEN_TYPE_STATEMENT,
 	TOKEN_TYPE_UNARY_OPERATOR,
 	TOKEN_TYPE_BINARY_OPERATOR,
 
@@ -117,6 +116,7 @@ class Parser {
 		}
 
 		const token = this.nextTokens[n - 1];
+
 		return types ? Parser.checkTokenType(token, types) : token;
 	}
 
@@ -129,6 +129,7 @@ class Parser {
 
 	popToken() {
 		const token = this.tokens.next();
+
 		if (token.done) {
 			throw new ParserError('Unexpected end of tokens');
 		}
@@ -137,6 +138,7 @@ class Parser {
 
 	generateAST() {
 		const ast = this.generateRootNode();
+
 		this.getExpectedToken(TOKEN_STRUCTURE_EOF);
 		return ast;
 	}
@@ -180,6 +182,7 @@ class Parser {
 
 	generateLiteral() {
 		const token = this.getExpectedToken(TOKEN_STRUCTURE_TEXT_LITERAL);
+
 		return {
 			type: PARSER_TYPE_TEXT_LITERAL,
 			value: token.value
@@ -188,9 +191,9 @@ class Parser {
 
 	generateStatement() {
 		const token = this.lookahead(2, [TOKEN_STATEMENT_IF, TOKEN_STATEMENT_INCLUDE]);
+
 		return (
-			token.subType === TOKEN_STATEMENT_IF
-				? this.generateBranchStatement() : this.generateIncludeStatement()
+			token.subType === TOKEN_STATEMENT_IF ? this.generateBranchStatement() : this.generateIncludeStatement()
 		);
 	}
 
@@ -218,13 +221,15 @@ class Parser {
 			]);
 
 			let condition;
+
 			if (token.subType !== TOKEN_STATEMENT_ELSE) {
 				condition = this.generateExpression();
 			}
 			// else it's an ELSE token
 
 			this.getExpectedToken(TOKEN_BOUNDARY_TAG_END);
 			const consequent = this.generateRootNode();
+
 			branches.push({
 				condition, consequent
 			});
@@ -250,6 +255,7 @@ class Parser {
 		]);
 
 		let value;
+
 		if (token.subType === TOKEN_VALUE_VARIABLE) {
 			value = {
 				type: PARSER_TYPE_VARIABLE,
@@ -281,6 +287,7 @@ class Parser {
 
 		while (true) {
 			let token = this.lookahead();
+
 			if (
 				token.type !== TOKEN_TYPE_BINARY_OPERATOR
 				|| PrecedenceTable[token.subType].precedence < minPrecedence
@@ -290,7 +297,7 @@ class Parser {
 			token = this.getExpectedToken(TOKEN_TYPE_BINARY_OPERATOR);
 			const precedenceInfo = PrecedenceTable[token.subType];
 			const nextPrecedence = precedenceInfo.precedence + 1;
-			// there currently is no right associative binary operator 
+			// there currently is no right associative binary operator
 			// const nextPrecedence = precedenceInfo.association === LEFT_ASSOCIATIVE
 			//	? precedenceInfo.precedence + 1 : precedenceInfo.precedence;
 
@@ -325,6 +332,7 @@ class Parser {
 
 	generateUnaryExpression() {
 		const token = this.getExpectedToken(TOKEN_TYPE_UNARY_OPERATOR);
+
 		return {
 			type: PARSER_TYPE_UNARY_OPERATOR,
 			operator: token.subType,
@@ -334,7 +342,9 @@ class Parser {
 
 	generateBracketExpression() {
 		this.getExpectedToken(TOKEN_BOUNDARY_BRACKET_OPEN);
+
 		const expression = this.generateExpression();
+
 		this.getExpectedToken(TOKEN_BOUNDARY_BRACKET_CLOSE);
 		return expression;
 	}
@@ -343,26 +353,28 @@ class Parser {
 		const token = this.getExpectedToken([
 			TOKEN_TYPE_VALUE, TOKEN_BOUNDARY_STRING_SINGLE, TOKEN_BOUNDARY_STRING_DOUBLE
 		]);
+
 		if (token.subType === TOKEN_VALUE_VARIABLE) {
 			return {
 				type: PARSER_TYPE_VARIABLE,
 				name: token.value
 			};
 		}
-		
+
 		let value;
+
 		if (token.subType === TOKEN_BOUNDARY_STRING_SINGLE || token.subType === TOKEN_BOUNDARY_STRING_DOUBLE) {
 			value = this.getExpectedToken(TOKEN_VALUE_STRING).value;
 			this.getExpectedToken(token.subType);
 		}
-		
+
 		if (token.subType === TOKEN_VALUE_FLOAT) {
 			value = parseFloat(token.value);
 		}
 		else if (token.subType === TOKEN_VALUE_INTEGER) {
 			value = parseInt(token.value, 10);
 		}
-		
+
 		return {
 			type: PARSER_TYPE_VALUE,
 			value

test/.eslintrc

@@ -0,0 +1,5 @@
+---
+extends: mitmaro/mocha
+rules:
+    func-names: off
+    no-undefined: off

test/Lexer/Lexer.isAtDelimiter.spec.js

@@ -4,7 +4,6 @@ const expect = require('chai').expect;
 const Lexer = require('../../src/Lexer');
 
 describe('Lexer.isAtDelimiter', function() {
-	
 	// false test cases
 	[
 		{
@@ -50,35 +49,39 @@ describe('Lexer.isAtDelimiter', function() {
 	].forEach((testCase) => {
 		it(`should return false with ${testCase.description}`, function() {
 			const lexer = new Lexer(testCase.input);
+
 			expect(lexer.isAtDelimiter()).to.be.false;
 		});
 	});
-	
+
 	[
 		'(', ')', '"', '\'', '!', '>', '<',
 		'{{', '}}', '==', '!=', '&&', '||', '>=', '<=',
 		'===', '!=='
 	].forEach((delimiter) => {
 		it(`should return ${delimiter} delimiter`, function() {
 			const lexer = new Lexer(delimiter);
+
 			expect(lexer.isAtDelimiter()).to.be.equal(delimiter);
 		});
 	});
-	
+
 	// the following need to be tested special because they are special characters
 	it(`should return space delimiter`, function() {
 		const lexer = new Lexer(' ');
+
 		expect(lexer.isAtDelimiter()).to.be.equal(' ');
 	});
-	
+
 	it(`should return tab delimiter`, function() {
 		const lexer = new Lexer('\t');
+
 		expect(lexer.isAtDelimiter()).to.be.equal('\t');
 	});
-	
+
 	it(`should return newline delimiter`, function() {
 		const lexer = new Lexer('\n');
+
 		expect(lexer.isAtDelimiter()).to.be.equal('\n');
 	});
-	
 });

test/Lexer/Lexer.scanNextDelimiter.spec.js

@@ -6,29 +6,34 @@ const Lexer = require('../../src/Lexer');
 describe('Lexer.scanNextDelimiter', function() {
 	it('should scan with empty string', function() {
 		const lexer = new Lexer('');
+
 		lexer.scanNextDelimiter();
 		expect(lexer.pointer).to.equal(0);
 	});
-	
+
 	it('should scan with non-delimiter', function() {
 		const lexer = new Lexer('aaa');
+
 		lexer.scanNextDelimiter();
 		expect(lexer.pointer).to.equal(0);
 	});
-	
+
 	it('should scan with single character delimiter', function() {
 		const lexer = new Lexer('(');
+
 		lexer.scanNextDelimiter();
 		expect(lexer.pointer).to.equal(1);
 	});
-	
+
 	it('should scan with double character delimiter', function() {
 		const lexer = new Lexer('==');
+
 		lexer.scanNextDelimiter();
 		expect(lexer.pointer).to.equal(2);
 	});
 	it('should scan with triple character delimiter', function() {
 		const lexer = new Lexer('===');
+
 		lexer.scanNextDelimiter();
 		expect(lexer.pointer).to.equal(3);
 	});