Update deps, use ES6 constructs, require Node 8.x

.eslintrc

@@ -1,3 +1,10 @@
 {
-  "extends": "standard"
+  "extends": "standard",
+  "plugins": [
+    "chai-friendly"
+  ],
+  "rules": {
+    "no-unused-expressions": 0,
+    "chai-friendly/no-unused-expressions": 2
+  }
 }

.travis.yml

@@ -1,3 +1,3 @@
 language: node_js
 node_js:
-  - "4.0"
+  - "8.0"

README.md

@@ -12,16 +12,16 @@ $ npm install --save jshiki
 ```
 
 ```javascript
-var jshiki = require('jshiki')
+const jshiki = require('jshiki')
 
 var expression = jshiki.parse('5 + (12 / 3)')
 var result = expression.eval() // 9
 
-expression = jshiki.parse('" Hello! ".trim() + " My name\'s " + name', {
-  scope: {
-    name: 'Azumi'
-  }
-})
+var expressionText = '" Hello! ".trim() + " My name\'s " + name'
+var scope = {
+  name: 'Azumi'
+}
+expression = jshiki.parse(expressionText, { scope })
 result = expression.eval() // "Hello! My name's Azumi"
 ```
 

astdelegate.js

@@ -1,105 +1,104 @@
-var operators = require('./operators')
-
-function ASTDelegate (options) {
-  options = options || {}
-  this.scope = options.scope || {}
-  this.expression = null
-  this.scopeIdentifier = undefined
-  this.indexIdentifier = undefined
-}
+const operators = require('./operators')
+
+class ASTDelegate {
+  constructor (options) {
+    options = options || {}
+    this.scope = options.scope || {}
+    this.expression = null
+    this.scopeIdentifier = undefined
+    this.indexIdentifier = undefined
+  }
 
-ASTDelegate.prototype = {
-  createUnaryExpression: function (op, arg) {
+  createUnaryExpression (op, arg) {
     if (!operators.unary[op]) {
       throw Error('Disallowed operator: ' + op)
     }
 
     return () => operators.unary[op](arg())
-  },
+  }
 
-  createBinaryExpression: function (op, left, right) {
+  createBinaryExpression (op, left, right) {
     if (!operators.binary[op]) {
       throw Error('Disallowed operator: ' + op)
     }
 
     return () => operators.binary[op](left(), right())
-  },
+  }
 
-  createConditionalExpression: function (test, consequent, alternate) {
+  createConditionalExpression (test, consequent, alternate) {
     return () => test() ? consequent() : alternate()
-  },
+  }
 
-  createIdentifier: function (name) {
+  createIdentifier (name) {
     var self = this
     return options => (options && options.child) ? name : self.scope[name]
-  },
+  }
 
-  createMemberExpression: function (accessor, object, property) {
+  createMemberExpression (accessor, object, property) {
     var exp = () => object()[property({ child: true })]
     exp.scope = object()
     return exp
-  },
+  }
 
-  createCallExpression: function (expression, args) {
+  createCallExpression (expression, args) {
     return () => expression().apply(expression.scope, args.map(arg => arg()))
-  },
+  }
 
-  createLiteral: function (token) {
+  createLiteral (token) {
     return () => token.value
-  },
+  }
 
-  createArrayExpression: function (elements) {
+  createArrayExpression (elements) {
     return () => {
       var array = []
       for (var i = 0; i < elements.length; i++) {
         array.push(elements[i]())
       }
       return array
     }
-  },
+  }
 
-  createProperty: function (kind, key, value) {
+  createProperty (kind, key, value) {
     return () => ({
       key: key({ child: true }),
       value: value()
     })
-  },
+  }
 
-  createObjectExpression: function (properties) {
+  createObjectExpression (properties) {
     return () => {
       var object = {}
       for (var i = 0; i < properties.length; i++) {
         object[properties[i]().key] = properties[i]().value
       }
       return object
     }
-  },
+  }
 
-  createFilter: function (name, args) {
+  createFilter (name, args) {
     // TODO (Should filters be supported?)
     throw new Error('Filters are not supported')
-  },
+  }
 
-  createAsExpression: function (expression, scopeIdentifier) {
+  createAsExpression (expression, scopeIdentifier) {
     this.expression = expression
     this.scopeIdentifier = scopeIdentifier
-  },
+  }
 
-  createInExpression: function (scopeIdentifier, indexIdentifier, expression) {
+  createInExpression (scopeIdentifier, indexIdentifier, expression) {
     this.expression = expression
     this.scopeIdentifier = scopeIdentifier
     this.indexIdentifier = indexIdentifier
-  },
+  }
 
-  createTopLevel: function (expression) {
+  createTopLevel (expression) {
     this.expression = expression
-  },
+  }
 
-  createThisExpression: function (expression) {
+  createThisExpression (expression) {
     // TODO
     throw new Error('`this` is not supported')
   }
-
 }
 
 module.exports = ASTDelegate

expression.js

@@ -1,18 +1,20 @@
-var esprima = require('./lib/esprima')
-var ASTDelegate = require('./astdelegate')
+const esprima = require('./lib/esprima')
+const ASTDelegate = require('./astdelegate')
 
-function Expression (str, options) {
-  options = options || {}
+class Expression {
+  constructor (str, options) {
+    options = options || {}
 
-  var delegate = new ASTDelegate(options)
-  try {
-    esprima.parse(str, delegate)
-  } catch (err) {
-    delegate = err
-  }
+    var delegate = new ASTDelegate(options)
+    try {
+      esprima.parse(str, delegate)
+    } catch (err) {
+      delegate = err
+    }
 
-  this.eval = function () {
-    return evaluate(delegate)
+    this.eval = function () {
+      return evaluate(delegate)
+    }
   }
 }
 

index.js

@@ -1,4 +1,4 @@
-var Expression = require('./expression')
+const Expression = require('./expression')
 
 function parseExpression (str, options) {
   return new Expression(str, options)

lib/esprima/index.js

@@ -700,7 +700,7 @@ function parseArguments () {
   expect('(')
 
   if (!match(')')) {
-    while (index < length) {
+    while (index < length) { // eslint-disable-line no-unmodified-loop-condition
       args.push(parseExpression())
       if (match(')')) {
         break
@@ -975,8 +975,8 @@ function parseTopLevel () {
 
   var expr = parseExpression()
   if (expr) {
-    if (lookahead.value === ',' || lookahead.value === 'in' &&
-      expr.type === Syntax.Identifier) {
+    if (lookahead.value === ',' || (lookahead.value === 'in' &&
+      expr.type === Syntax.Identifier)) {
       parseInExpression(expr)
     } else {
       parseFilters()