Initial Runtime

Author: MitMaro

package.json

@@ -23,5 +23,8 @@
     "eslint-plugin-strict-newline": "^1.0.0",
     "istanbul": "^0.4.4",
     "mocha": "^2.5.3"
+  },
+  "dependencies": {
+    "async": "^2.0.1"
   }
 }

src/Parser.js

@@ -137,9 +137,10 @@ class Parser {
 	}
 
 	generateAST() {
+		this.sources = [];
 		const ast = this.generateRootNode();
-
 		this.getExpectedToken(TOKEN_STRUCTURE_EOF);
+		ast.sources = this.sources;
 		return ast;
 	}
 
@@ -275,6 +276,7 @@ class Parser {
 
 		this.getExpectedToken(TOKEN_BOUNDARY_TAG_END);
 
+		this.sources.push(value);
 		return {
 			type: PARSER_TYPE_INCLUDE,
 			value

src/Runner.js

@@ -1,7 +1,30 @@
 'use strict';
 
+const async = require('async');
+const fs = require('fs');
 const RuntimeError = require('./error/Runtime');
 
+const Parser = require('./Parser');
+const Lexer = require('./Lexer');
+
+// credit: http://stackoverflow.com/a/3886106/124861
+function isFloat(n){
+	return Number(n) === n && n % 1 !== 0;
+}
+
+function floatEqual(a, b, epsilon = Number.EPSILON) {
+		if (a === b) {
+			return true;
+		}
+
+		if (isNaN(a) || isNaN(b) || !isFinite(a) || !isFinite(b)) {
+			return false;
+		}
+
+		const diff = Math.abs(a - b);
+		return diff < epsilon ? true : diff <= Math.max(Math.abs(a), Math.abs(b)) * epsilon;
+}
+
 const {
 	OPERATOR_EQUALS,
 	OPERATOR_NOT_EQUALS,
@@ -15,7 +38,6 @@ const {
 	OPERATOR_GREATER_EQUAL_THAN,
 	OPERATOR_LESS_EQUAL_THAN,
 
-	PARSER_TYPE_ROOT,
 	PARSER_TYPE_TEXT_LITERAL,
 	PARSER_TYPE_INCLUDE,
 	PARSER_TYPE_VALUE,
@@ -26,43 +48,64 @@ const {
 } = require('./constants');
 
 class Runner {
-	constructor(ast, input) {
-		this.ast = ast;
-		this.input = input;
+	constructor() {
+		this.astCache = {};
 		this.result = [];
 	}
 
-	invoke() {
-		this.invokeRoot(this.ast);
+	invoke(ast, input, cb) {
+		this.result = [];
+		this.input = input;
+		this.loadSources(ast.sources, (err) => {
+			return err ? cb(err) : cb(null, this.invokeStatements(ast.statements));
+		});
+	}
+
+	loadSources(sources, cb) {
+		const tasks = {};
+
+		for (const value of sources) {
+			const path = value.type === PARSER_TYPE_VARIABLE ? this.getValueFromVariable(value.name) : value.value;
+			tasks[path] = fs.readFile.bind(fs, path);
+		}
+
+		async.parallel(tasks, (err, files) => {
+			if (err) {
+				return cb(err);
+			}
+			for (const f in files) {
+				this.astCache[f] = new Parser(new Lexer(files[f])).generateAST();
+			}
+			return cb();
+		});
 	}
 
-	invokeRoot(ast) {
-		for (const statement in ast.statements) {
+	invokeStatements(statements) {
+		for (const statement of statements) {
 			if (statement.type === PARSER_TYPE_TEXT_LITERAL) {
 				this.result.push(statement.value);
 			}
 			else if (statement.type === PARSER_TYPE_INCLUDE) {
 				this.invokeInclude(statement);
 			}
-			else (statement.type === PARSER_TYPE_BRANCH) {
+			else if (statement.type === PARSER_TYPE_BRANCH) {
 				this.invokeBranch(statement);
 			}
+			throw new RuntimeError(`Unexpected statement: ${statement}`);
 		}
 	}
 
 	invokeInclude(statement) {
-		const path = statement.value;
 
-		if (typeof path !== string) {
-			throw new RuntimeError('Non string type passed to include.')
-		}
-		// TODO: include other file
+		if ()
+
+		this.invoke(ast);
 	}
 
 	invokeBranch(statement) {
 		for (const branch of statement.branches) {
-			if (this.evaluateExpression(branch.condition)) {
-
+			if (branch.condition === undefined || this.evaluateExpression(branch.condition)) {
+				return this.invokeStatements(branch.consequent.statements);
 			}
 		}
 	}
@@ -78,38 +121,65 @@ class Runner {
 			return expression.value;
 		}
 		else if (expression.type === PARSER_TYPE_VARIABLE) {
-			return this.getValueFromVariable(expression.value);
+			return this.getValueFromVariable(expression.name);
 		}
 	}
 
 	evaluateBinaryExpression(expression) {
+		const leftValue = this.evaluateExpression(expression.left);
+		const rightValue = this.evaluateExpression(expression.right);
+
 		if (expression.operator === OPERATOR_EQUALS) {
-			return this.evaluateExpression(expression.left) == this.evaluateExpression(expression.right);
+			return this.evaluateEquals(leftValue, rightValue);
 		}
 
 		if (expression.operator === OPERATOR_NOT_EQUALS) {
-			return this.evaluateExpression(expression.left) != this.evaluateExpression(expression.right);
+			return !this.evaluateEquals(leftValue, rightValue);
 		}
 
 		if (expression.operator === OPERATOR_STRICT_EQUALS) {
-			return this.evaluateExpression(expression.left) === this.evaluateExpression(expression.right);
+			return this.evaluateEquals(leftValue, rightValue, true);
 		}
 
 		if (expression.operator === OPERATOR_STRICT_NOT_EQUALS) {
-			return this.evaluateExpression(expression.left) !== this.evaluateExpression(expression.right);
+			return !this.evaluateEquals(leftValue, rightValue, true);
+		}
+
+		if (expression.operator === OPERATOR_GREATER_EQUAL_THAN) {
+			return leftValue > rightValue || this.evaluateEquals(leftValue, rightValue);
+		}
+
+		if (expression.operator === OPERATOR_LESS_EQUAL_THAN) {
+			return leftValue < rightValue || this.evaluateEquals(leftValue, rightValue);
+		}
+
+		if (expression.operator === OPERATOR_GREATER_THAN) {
+			return leftValue > rightValue;
+		}
+
+		if (expression.operator === OPERATOR_LESS_THAN) {
+			return leftValue > rightValue;
 		}
 
 		if (expression.operator === OPERATOR_AND) {
-			return this.evaluateExpression(expression.left) && this.evaluateExpression(expression.right);
+			return leftValue && rightValue;
 		}
 
 		if (expression.operator === OPERATOR_OR) {
-			return this.evaluateExpression(expression.left) || this.evaluateExpression(expression.right);
+			return leftValue || rightValue;
 		}
 
 		throw new RuntimeError(`Unknown operator: ${expression.operator}`);
 	}
 
+	evaluateEquals(leftValue, rightValue, strict = false) {
+		if (isFloat(leftValue) && isFloat(rightValue)) {
+			return floatEqual(leftValue, rightValue);
+		}
+
+		return strict ? leftValue === rightValue : leftValue == rightValue;
+	}
+
 	evaluateUnaryExpression(expression) {
 		if (expression.operator === OPERATOR_NOT) {
 			return !this.evaluateExpression(expression.expression);
@@ -126,3 +196,5 @@ class Runner {
 	}
 
 }
+
+module.exports = Runner;

test/Parser/Parser.generate.spec.js

@@ -36,6 +36,7 @@ describe('Parser.generate', function() {
 			nb.include(nb.value('foo'))
 		];
 
+		expect(result.sources).to.deep.equal([nb.value('foo')]);
 		expect(result.statements).to.deep.equal(expected);
 	});
 
@@ -45,9 +46,16 @@ describe('Parser.generate', function() {
 			nb.include(nb.variable('foo'))
 		];
 
+		expect(result.sources).to.deep.equal([nb.variable('foo')]);
 		expect(result.statements).to.deep.equal(expected);
 	});
 
+	it('should set sources from inside if blocks', function() {
+		const result = getParserResult('{{if bar}}{{include baz}}{{fi}}');
+
+		expect(result.sources).to.deep.equal([nb.variable('baz')]);
+	});
+
 	it('should parse with basic if statement', function() {
 		const result = getParserResult('{{if foo}}bar{{fi}}');
 		const expected = [