Added eslint

- Fixed existing errors
- Minor refactoring

Author: MitMaro

.eslintignore

@@ -0,0 +1,3 @@
+.nyc_output
+coverage
+node_modules

.eslintrc

@@ -0,0 +1,15 @@
+---
+root: true
+env:
+    node: true
+    es6: true
+extends: mitmaro
+rules:
+    no-constant-condition:
+        - error
+        - checkLoops: false
+    newline-after-var: off
+    no-extra-parens:
+        - error
+        - all
+        - nestedBinaryExpressions: false

package.json

@@ -16,6 +16,9 @@
     "ava": "^0.15.2",
     "chalk": "^1.1.3",
     "diff": "^2.2.3",
+    "eslint": "^3.0.0",
+    "eslint-config-mitmaro": "^1.0.0",
+    "eslint-plugin-strict-newline": "^1.0.0",
     "nyc": "^6.4.4"
   },
   "nyc": {

src/Lexer.js

@@ -1,3 +1,4 @@
+/* eslint max-depth: "off" */
 'use strict';
 
 const LexerError = require('./error/Lexer');
@@ -30,17 +31,17 @@ const {
 	TOKEN_STATEMENT_FI,
 	TOKEN_STATEMENT_INCLUDE,
 
-	TOKEN_OPERATOR_EQUALS,
-	TOKEN_OPERATOR_NOT_EQUALS,
-	TOKEN_OPERATOR_STRICT_EQUALS,
-	TOKEN_OPERATOR_STRICT_NOT_EQUALS,
-	TOKEN_OPERATOR_AND,
-	TOKEN_OPERATOR_OR,
-	TOKEN_OPERATOR_NOT,
-	TOKEN_OPERATOR_GREATER_THAN,
-	TOKEN_OPERATOR_LESS_THAN,
-	TOKEN_OPERATOR_GREATER_EQUAL_THAN,
-	TOKEN_OPERATOR_LESS_EQUAL_THAN
+	OPERATOR_EQUALS,
+	OPERATOR_NOT_EQUALS,
+	OPERATOR_STRICT_EQUALS,
+	OPERATOR_STRICT_NOT_EQUALS,
+	OPERATOR_AND,
+	OPERATOR_OR,
+	OPERATOR_NOT,
+	OPERATOR_GREATER_THAN,
+	OPERATOR_LESS_THAN,
+	OPERATOR_GREATER_EQUAL_THAN,
+	OPERATOR_LESS_EQUAL_THAN
 } = require('./constants');
 
 const boundaryTypeLookup = {
@@ -53,29 +54,27 @@ const boundaryTypeLookup = {
 };
 
 const statementTypeLookup = {
-	'if': TOKEN_STATEMENT_IF,
-	'elif': TOKEN_STATEMENT_ELIF,
-	'else': TOKEN_STATEMENT_ELSE,
-	'fi': TOKEN_STATEMENT_FI,
-	'include': TOKEN_STATEMENT_INCLUDE
+	if: TOKEN_STATEMENT_IF,
+	elif: TOKEN_STATEMENT_ELIF,
+	else: TOKEN_STATEMENT_ELSE,
+	fi: TOKEN_STATEMENT_FI,
+	include: TOKEN_STATEMENT_INCLUDE
 };
 
 const binaryOperatorTypeLookup = {
-	'==': TOKEN_OPERATOR_EQUALS,
-	'!=': TOKEN_OPERATOR_NOT_EQUALS,
-	'===': TOKEN_OPERATOR_STRICT_EQUALS,
-	'!==': TOKEN_OPERATOR_STRICT_NOT_EQUALS,
-	'&&': TOKEN_OPERATOR_AND,
-	'||': TOKEN_OPERATOR_OR,
-	'>': TOKEN_OPERATOR_GREATER_THAN,
-	'<': TOKEN_OPERATOR_LESS_THAN,
-	'>=': TOKEN_OPERATOR_GREATER_EQUAL_THAN,
-	'<=': TOKEN_OPERATOR_LESS_EQUAL_THAN
+	'==': OPERATOR_EQUALS,
+	'!=': OPERATOR_NOT_EQUALS,
+	'===': OPERATOR_STRICT_EQUALS,
+	'!==': OPERATOR_STRICT_NOT_EQUALS,
+	'&&': OPERATOR_AND,
+	'||': OPERATOR_OR,
+	'>': OPERATOR_GREATER_THAN,
+	'<': OPERATOR_LESS_THAN,
+	'>=': OPERATOR_GREATER_EQUAL_THAN,
+	'<=': OPERATOR_LESS_EQUAL_THAN
 };
 
-const unaryOperatorTypeLookup = {
-	'!': TOKEN_OPERATOR_NOT
-};
+const unaryOperatorTypeLookup = { '!': OPERATOR_NOT };
 
 const STATE_TAG = 'TAG';
 const STATE_TEXT_LITERAL = 'TEXT';
@@ -86,7 +85,7 @@ const generalDelimiters = [
 	' ', '\t', '\n'
 ];
 
-const delimiters = [null, [], [], []];
+const delimiters = [null, [], [], [] ];
 
 // build delimiters
 Array.prototype.concat(
@@ -95,7 +94,7 @@ Array.prototype.concat(
 	Object.keys(binaryOperatorTypeLookup),
 	Object.keys(unaryOperatorTypeLookup)
 ).forEach((delimiter) => {
-	delimiters[delimiter.length].push(delimiter)
+	delimiters[delimiter.length].push(delimiter);
 });
 
 class Lexer {
@@ -104,21 +103,21 @@ class Lexer {
 		this.pointer = 0;
 		this.input = input;
 		// length used for cases of checking ahead by one character from pointer
-		this._lookAheadLength = this.input.length -1;
-		this._stringDelimiter = null;
+		this.lookAheadLength = this.input.length - 1;
+		this.stringDelimiter = null;
 	}
 
 	// skip all whitespace or until EOF reached
-	_skipWhitespace() {
+	skipWhitespace() {
 		while (this.pointer < this.input.length && this.input[this.pointer].trim().length === 0) {
 			this.pointer++;
 		}
 	}
 
 	// scan until {{ is found or EOF reached
-	_scanTextLiteral() {
+	scanTextLiteral() {
 		while (
-			this.pointer < this._lookAheadLength
+			this.pointer < this.lookAheadLength
 			&& !(
 				this.input[this.pointer] === '{'
 				&& this.input[this.pointer + 1] === '{'
@@ -129,31 +128,28 @@ class Lexer {
 
 		// because we look two characters ahead, we need to increment the
 		// pointer by one if end of input is reached
-		if (this._lookAheadLength >= 0 && this.pointer >= this._lookAheadLength) {
+		if (this.lookAheadLength >= 0 && this.pointer >= this.lookAheadLength) {
 			this.pointer++;
 		}
 	}
 
-	//
-	_scanString() {
+	scanString() {
 		// if next character is the delimiter we have a zero length string
-		if (this.input[this.pointer] === this._stringDelimiter) {
+		if (this.input[this.pointer] === this.stringDelimiter) {
 			return;
 		}
 
-		while (this.pointer < this._lookAheadLength) {
-
+		while (this.pointer < this.lookAheadLength) {
 			// check ahead for delimiter but only if current isn't an escape
-			if (this.input[this.pointer + 1] === this._stringDelimiter && this.input[this.pointer] !== '\\') {
+			if (this.input[this.pointer + 1] === this.stringDelimiter && this.input[this.pointer] !== '\\') {
 				break;
 			}
-
 			this.pointer++;
 		}
 		this.pointer++;
 	}
 
-	_isAtDelimiter() {
+	isAtDelimiter() {
 		for (let length = 3; length > 0; length--) {
 			// if we don't have enough input remaining then stop
 			if (length + this.pointer > this.input.length) {
@@ -176,32 +172,32 @@ class Lexer {
 
 
 	// scan up to the next delimiter
-	_scanToNextDelimiter() {
+	scanToNextDelimiter() {
 		// if already at delimiter
-		if (this._isAtDelimiter()) {
+		if (this.isAtDelimiter()) {
 			return;
 		}
 		this.pointer++;
 
 		while (this.pointer < this.input.length) {
-			if (this._isAtDelimiter()) {
+			if (this.isAtDelimiter()) {
 				return;
 			}
 			this.pointer++;
 		}
 	}
 
 	// scan pass the next delimiter
-	_scanNextDelimiter() {
-		const delimiter = this._isAtDelimiter() || '';
-		this.pointer += delimiter.length;
+	scanNextDelimiter() {
+		const delimiter = this.isAtDelimiter() || '';
+		this.pointer = this.pointer + delimiter.length;
 	}
 
-	* tokens() {
+	*tokens() {
 		while (this.pointer < this.input.length) {
 			if (this.state === STATE_TEXT_LITERAL) {
-				let startIndex = this.pointer;
-				this._scanTextLiteral();
+				const startIndex = this.pointer;
+				this.scanTextLiteral();
 				this.state = STATE_TAG;
 				const value = this.input.substring(startIndex, this.pointer);
 				if (!value.length) {
@@ -217,33 +213,33 @@ class Lexer {
 			}
 			else if (this.state === STATE_TAG || this.state === STATE_END_STRING) {
 				let type;
-				this._skipWhitespace();
+				this.skipWhitespace();
 				let startIndex = this.pointer;
 
 				// scan until next delimiter
-				this._scanToNextDelimiter();
+				this.scanToNextDelimiter();
 				let value = this.input.substring(startIndex, this.pointer);
 				if (value.length) {
 					type = statementTypeLookup[value];
 					if (type) {
 						yield {
 							type: TOKEN_TYPE_STATEMENT,
 							subType: type,
-							value: value,
+							value,
 							startIndex,
 							endIndex: this.pointer
 						};
 						continue;
 					}
 
 					// if first digit is a number, it's a numerical value
-					if ((value[0] >= '0' && value[0] <= '9') || value[0] === '-')  {
+					if ((value[0] >= '0' && value[0] <= '9') || value[0] === '-') {
 						// floats have a decimal number
-						if (value.indexOf('.') !== -1) {
-							type = TOKEN_VALUE_FLOAT;
+						if (value.indexOf('.') === -1) {
+							type = TOKEN_VALUE_INTEGER;
 						}
 						else {
-							type = TOKEN_VALUE_INTEGER;
+							type = TOKEN_VALUE_FLOAT;
 						}
 					}
 					else {
@@ -253,21 +249,21 @@ class Lexer {
 					yield {
 						type: TOKEN_TYPE_VALUE,
 						subType: type,
-						value: value,
+						value,
 						startIndex,
 						endIndex: this.pointer
 					};
 					continue;
 				}
 
 				startIndex = this.pointer;
-				this._scanNextDelimiter();
+				this.scanNextDelimiter();
 				value = this.input.substring(startIndex, this.pointer);
 				// boundary types are the most complicated
 				type = boundaryTypeLookup[value];
 				if (type) {
 					if (type === TOKEN_BOUNDARY_STRING_DOUBLE || type === TOKEN_BOUNDARY_STRING_SINGLE) {
-						this._stringDelimiter = value;
+						this.stringDelimiter = value;
 						this.state = this.state === STATE_END_STRING ? STATE_TAG : STATE_STRING;
 					}
 					else if (type === TOKEN_BOUNDARY_TAG_END) {
@@ -276,7 +272,7 @@ class Lexer {
 					yield {
 						type: TOKEN_TYPE_BOUNDARY,
 						subType: type,
-						value: value,
+						value,
 						startIndex,
 						endIndex: this.pointer
 					};
@@ -287,7 +283,7 @@ class Lexer {
 					yield {
 						type: TOKEN_TYPE_BINARY_OPERATOR,
 						subType: type,
-						value: value,
+						value,
 						startIndex,
 						endIndex: this.pointer
 					};
@@ -297,22 +293,22 @@ class Lexer {
 				yield {
 					type: TOKEN_TYPE_UNARY_OPERATOR,
 					subType: type,
-					value: value,
+					value,
 					startIndex,
 					endIndex: this.pointer
 				};
 			}
 			else if (this.state === STATE_STRING) {
-				let startIndex = this.pointer;
-				this._scanString();
+				const startIndex = this.pointer;
+				this.scanString();
 				this.state = STATE_END_STRING;
 				yield {
 					type: TOKEN_TYPE_VALUE,
 					subType: TOKEN_VALUE_STRING,
 					value: this.input.substring(startIndex, this.pointer),
 					startIndex,
 					endIndex: this.pointer
-				}
+				};
 			}
 			else {
 				throw new LexerError('Invalid state incurred');

src/constants.js

@@ -25,17 +25,17 @@ module.exports = {
 	TOKEN_BOUNDARY_STRING_SINGLE: 'STRING_SINGLE',
 	TOKEN_BOUNDARY_STRING_DOUBLE: 'STRING_DOUBLE',
 
-	TOKEN_OPERATOR_EQUALS: 'EQUALS',
-	TOKEN_OPERATOR_NOT_EQUALS: 'NOT_EQUALS',
-	TOKEN_OPERATOR_STRICT_EQUALS: 'STRICT_EQUALS',
-	TOKEN_OPERATOR_STRICT_NOT_EQUALS: 'STRICT_NOT_EQUALS',
-	TOKEN_OPERATOR_AND: 'AND',
-	TOKEN_OPERATOR_OR: 'OR',
-	TOKEN_OPERATOR_NOT: 'NOT',
-	TOKEN_OPERATOR_GREATER_THAN: 'GREATER_THAN',
-	TOKEN_OPERATOR_LESS_THAN: 'LESS_THAN',
-	TOKEN_OPERATOR_GREATER_EQUAL_THAN: 'GREATER_EQUAL_THAN',
-	TOKEN_OPERATOR_LESS_EQUAL_THAN: 'LESS_EQUAL_THAN',
+	OPERATOR_EQUALS: 'EQUALS',
+	OPERATOR_NOT_EQUALS: 'NOT_EQUALS',
+	OPERATOR_STRICT_EQUALS: 'STRICT_EQUALS',
+	OPERATOR_STRICT_NOT_EQUALS: 'STRICT_NOT_EQUALS',
+	OPERATOR_AND: 'AND',
+	OPERATOR_OR: 'OR',
+	OPERATOR_NOT: 'NOT',
+	OPERATOR_GREATER_THAN: 'GREATER_THAN',
+	OPERATOR_LESS_THAN: 'LESS_THAN',
+	OPERATOR_GREATER_EQUAL_THAN: 'GREATER_EQUAL_THAN',
+	OPERATOR_LESS_EQUAL_THAN: 'LESS_EQUAL_THAN',
 
 	TOKEN_VALUE_VARIABLE: 'VARIABLE',
 	TOKEN_VALUE_STRING: 'STRING',

src/error/Lexer.js

@@ -3,9 +3,6 @@
 const GeneralError = require('./General');
 
 class LexerError extends GeneralError {
-	constructor(message) {
-		super(message);
-	}
 }
 
 module.exports = LexerError;