Add REPL

Author: fnogatz

repl.js

@@ -0,0 +1,82 @@
+module.exports = Repl
+
+var repl = require('repl')
+var spinner = require('char-spinner')
+var CHR = require('./src/index')
+var parse = require('./src/repl.peg.js').parse
+
+function Repl () {
+  var chr = new CHR()
+
+  var r = repl.start({
+    prompt: 'CHR > ',
+    input: process.stdin,
+    output: process.stdout,
+    eval: function (cmd, context, filename, callback) {
+      // try Program
+      try {
+        var rules = parse(cmd.trim(), { startRule: 'Program' })
+      } catch (e) {
+        // try Query
+        try {
+          var queries = parse(cmd.trim(), { startRule: 'Query' })
+        } catch (e) {
+          // no query
+          var res = eval(cmd)
+          callback(null, res)
+
+          return
+        }
+
+        // run query
+        var spin = spinner({
+          stream: r.outputStream
+        })
+
+        var queryPromise = queries.reduce(function (promise, query) {
+          return promise.then(function () {
+            var chrCmd = 'chr.' + query.original
+            if (query.original.slice(-1)[0] !== ')') {
+              chrCmd += '()'
+            }
+            var queryPromise = eval(chrCmd)
+            return queryPromise
+          })
+        }, Promise.resolve())
+
+        queryPromise.then(function () {
+          clearInterval(spin)
+          r.output.write(chr.Store.toString().split('\n').map(function (row) {
+            return '  '+row
+          }).join('\n'))
+          callback()
+        }).catch(function (e) {
+          clearInterval(spin)
+          r.output.write('  [Error] ' + errorMsg(e) + '\n')
+          r.output.write(chr.Store.toString())
+          callback()
+        })
+
+        return
+      }
+
+      // add rules
+      chr(rules)
+      r.output.write('  [Rule' + (rules.body.length > 1 ? 's' : '') + '] Added.\n')
+
+      callback()
+      return
+    }
+  })
+}
+
+function errorMsg (e) {
+  e = e.toString()
+
+  if (e.match(/^TypeError: chr\..* is not a function$/)) {
+    var constraint = e.replace(/^TypeError: chr\.(.*) is not a function$/, '$1')
+    return 'Undefined constraint: '+constraint
+  }
+
+  return e
+}

src/compile/head.js

@@ -312,6 +312,33 @@ Compiler.prototype.generateTellPromises = function generateTellPromises () {
       }
       return
     }
+
+    if (body.type === 'Replacement' && body.hasOwnProperty('func')) {
+      var func = eval(body.func)
+      var params = util.getFunctionParameters(func)
+      var lastParamName = util.getLastParamName(params, true)
+
+      if (lastParamName && self.opts.defaultCallbackNames.indexOf(lastParamName) > -1) {
+        // async
+        parts.push(
+          indent(1) + 'return new Promise(function (s) {',
+          indent(2) + '('+body.func+').apply(self, [' + util.replaceLastParam(params,'s') + '])',
+          indent(1) + '})',
+          '})'
+        )
+      } else {
+        // sync
+        parts.push(
+          indent(1) + 'return new Promise(function (s) {',
+          indent(2) + '('+body.func+').apply(self, [' + params + '])',
+          indent(2) + 's()',
+          indent(1) + '})',
+          '})'
+        )
+      }
+
+      return
+    }
   })
 
   parts.push(

src/compile/util.js

@@ -4,6 +4,7 @@ module.exports.indentBy = indentBy
 module.exports.destructuring = destructuring
 module.exports.getFunctionParameters = getFunctionParameters
 module.exports.getLastParamName = getLastParamName
+module.exports.replaceLastParam = replaceLastParam
 module.exports.isArrowFunction = isArrowFunction
 
 function indent (level, text, spaces) {
@@ -70,6 +71,10 @@ function getLastParamName (params) {
   return params.replace(/(^.*,|^)\s*([^,]+)$/g, '$2')
 }
 
+function replaceLastParam (params, replacement) {
+  return params.replace(/((^.*,|^)\s*)([^,]+)$/g, '$1'+replacement)
+}
+
 function isArrowFunction (func) {
   return !func.hasOwnProperty('prototype')
 }

src/parser.pegjs

@@ -413,6 +413,12 @@ Replacement
         expr: func
       };
     }
+  / ReplacementOpeningSymbol __ func:$(ArrowFunction) __ ReplacementClosingSymbol {
+      return {
+        type: 'Replacement',
+        func: func
+      };
+    }
   / ReplacementOpeningSymbol __ expr:$(Expression) __ ReplacementClosingSymbol {
       return {
         type: 'Replacement',