initial commit of tracer branch. this will be merged in or abandoned depnding on whether i can get the performance penalty down to a reasonable multiplier of the current master branch build. refs #2

Author: nwronski

CHANGELOG.md

@@ -2,6 +2,8 @@
 All notable changes to this project will be documented in this file.
 
 ## [Unreleased][unreleased]
+### Changed
+- Created a `tracer` branch to continue developing the `Tracer` class into something viable.
 
 ## [v0.10.1] - 2015-07-09
 ### Changed

Gruntfile.js

@@ -70,7 +70,7 @@ module.exports = function(grunt) {
         options: {
           failOnError: true
         },
-        command: './node_modules/.bin/pegjs --optimize "speed" src/grammar.pegjs lib/parser.js'
+        command: './node_modules/.bin/pegjs --trace src/grammar.pegjs lib/parser.js'
       },
       test: {
         options: {

README.md

@@ -5,6 +5,9 @@
 [![devDependencies Status Image](https://img.shields.io/david/dev/codeschool/sqlite-parser.svg)](https://github.com/codeschool/sqlite-parser/)
 [![License Type Image](https://img.shields.io/github/license/codeschool/sqlite-parser.svg)](https://github.com/codeschool/sqlite-parser/blob/master/LICENSE)
 
+## This branch is a work-in-progress
+_Note: There is a currently a significant performance penalty (14x) to using this branch for the smart-error functionality._
+
 This library parses SQLite queries, using JavaScript, and generates
 _abstract syntax tree_ (AST) representations of the input strings. A
 syntax error is produced if an AST cannot be generated.
@@ -47,6 +50,13 @@ sqliteParser(sampleSQL, function (err, res) {
 });
 ```
 
+## Syntax Errors
+
+This parser uses the `--trace` flag exposed in `pegjs` to create "smart" error
+messages. The parser includes a `Trace` class that keeps track of which grammar
+rules were being traversed just prior to the error and uses that information
+to improve the error message and location information.
+
 ## AST
 
 **NOTE: The SQLite AST is a work-in-progress and subject to change.**

demo/js/sqlite-parser-demo.js

@@ -4,17 +4,22 @@
  * @author Nick Wronski <nick@javascript.com>
  */
  ;(function (root) {
-  var parser      = require('./lib/parser');
+  var parser      = require('./lib/parser'),
+      Tracer      = require('./lib/tracer');
 
   function sqliteParser(source, callback) {
+    var t = Tracer(), res;
     try {
-      callback(null, parser.parse(source));
+      res = parser.parse(source, {
+        'tracer': t
+      });
+      callback(null, res);
     } catch (e) {
-      callback(e);
+      callback(e instanceof parser.SyntaxError ? t.smartError(e) : e);
     }
   }
   sqliteParser['NAME'] = 'sqlite-parser';
-  sqliteParser['VERSION'] = '0.10.1';
+  sqliteParser['VERSION'] = '0.11.0';
 
   module.exports = root.sqliteParser = sqliteParser;
 })(typeof self === 'object' ? self : global);

dist/sqlite-parser-min.js

@@ -0,0 +1,109 @@
+/*!
+ * sqlite-parser
+ * @copyright Code School 2015 {@link http://codeschool.com}
+ * @author Nick Wronski <nick@javascript.com>
+ */
+var parserUtils = require('./parser-util');
+
+module.exports = (function (util) {
+  Tracer = function Tracer() {
+    if (!(this instanceof Tracer)) {
+      return new Tracer();
+    }
+    this.events = [];
+    this.indentation = 0;
+    this.whitespaceRule = /(^whitespace)|(char$)|(^[oe]$)/i;
+    this.statementRule = /Statement$/i;
+    this.firstNodeRule = /(Statement|Clause)$/i;
+  };
+
+  Tracer.prototype.trace = function trace(event) {
+    var that = this, lastIndex, lastWsIndex;
+    event.indentation = this.indentation;
+    switch (event.type) {
+      case 'rule.enter':
+        // add entered leaf
+        this.events.push(event);
+        this.indentation += 1;
+        break;
+      case 'rule.match':
+         this.indentation -= 1;
+        break;
+      case 'rule.fail':
+        // remove failed leaf
+        lastIndex = util.findLastIndex(this.events, {rule: event.rule});
+        lastWsIndex = util.findLastIndex(this.events, function (e) {
+          return !that.whitespaceRule.test(e.rule);
+        });
+        if (that.whitespaceRule.test(event.rule) || lastIndex === lastWsIndex) {
+          this.events.splice(lastIndex, 1);
+        }
+        this.indentation -= 1;
+        break;
+    }
+  };
+
+  /**
+   * @note
+   *  There is way too much magic/nonsense in this method now. Need to
+   *  come up with an alternative approach to getting the right
+   *  information for syntax errors.
+   */
+  Tracer.prototype.smartError = function smartError(err) {
+    var that = this, message, location, chain, chainDetail, firstNode,
+        bestNode = {indentation: -1}, deep = false, stmts = 0,
+        namedEvents = this.events
+        .filter(function (e) {
+          return e.description !== null &&
+                  !that.whitespaceRule.test(e.rule);
+        })
+        .reverse();
+
+    chain = util.takeWhile(namedEvents, function (elem) {
+      if (/^(sym\_semi)$/i.test(elem.rule)) {
+        stmts += 1;
+      }
+      if (stmts > 1) {
+        return false;
+      }
+      if (!deep) {
+        if (elem.indentation > bestNode.indentation) {
+          bestNode = elem;
+        } else {
+          deep = true;
+        }
+      } else if (/^(stmt)$/i.test(elem.rule)) {
+        deep = true;
+        return true;
+      }
+      return true;
+    });
+
+    if (chain.length) {
+      location = bestNode.location;
+      firstNode = util.findWhere(chain, function (elem) {
+        return that.firstNodeRule.test(elem.description)  &&
+                elem.description !== bestNode.description &&
+                elem.indentation !== bestNode.indentation;
+      });
+      if (firstNode != null) {
+        if (this.statementRule.test(bestNode.description) &&
+            this.statementRule.test(firstNode.description)) {
+          chainDetail = firstNode.description;
+        } else {
+          chainDetail = bestNode.description + ' (' + firstNode.description + ')';
+        }
+      } else {
+        chainDetail = bestNode.description;
+      }
+      message = 'Syntax error found near ' + chainDetail;
+      util.extend(err, {
+        'message': message,
+        'location': location
+      });
+    }
+    return err;
+  };
+
+  return Tracer;
+})(parserUtils);

dist/sqlite-parser.js

@@ -2,7 +2,7 @@
   "name": "sqlite-parser",
   "description": "JavaScript implentation of SQLite 3 query parser",
   "author": "Code School (http://codeschool.com)",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "contributors": [
     "Nick Wronski <nick@javascript.com>"
   ],
@@ -43,7 +43,7 @@
     "grunt-shell": "^1.1.2",
     "lodash": "^3.10.0",
     "mocha": "^2.2.5",
-    "pegjs": "git+https://github.com/dmajda/pegjs.git#master",
+    "pegjs": "git+https://github.com/nwronski/pegjs.git#master",
     "prettyjson": "^1.1.2",
     "promise": "^7.0.3"
   },