chore: Add the Nearley parser to the performance comparison

Author: prantlf

.gitignore

@@ -2,6 +2,7 @@
 .nyc_output
 benchmarks/jison/*.js
 benchmarks/pegjs/*.js
+benchmarks/nearley/*.js
 coverage
 node_modules
 lib/jsonlint*.js

benchmarks/nearley/pure.ne

@@ -0,0 +1,81 @@
+# http://www.json.org/
+# http://www.asciitable.com/
+@{%
+
+const moo = require('moo')
+
+let lexer = moo.compile({
+    space: {match: /\s+/, lineBreaks: true},
+    number: /-?(?:[0-9]|[1-9][0-9]+)(?:\.[0-9]+)?(?:[eE][-+]?[0-9]+)?\b/,
+    string: /"(?:\\["bfnrt\/\\]|\\u[a-fA-F0-9]{4}|[^"\\])*"/,
+    '{': '{',
+    '}': '}',
+    '[': '[',
+    ']': ']',
+    ',': ',',
+    ':': ':',
+    true: 'true',
+    false: 'false',
+    null: 'null',
+})
+
+%}
+
+@lexer lexer
+
+json -> _ (object | array) _ {% function(d) { return d[1][0]; } %}
+
+object -> "{" _ "}" {% function(d) { return {}; } %}
+    | "{" _ pair (_ "," _ pair):* _ "}" {% extractObject %}
+
+array -> "[" _ "]" {% function(d) { return []; } %}
+    | "[" _ value (_ "," _ value):* _ "]" {% extractArray %}
+
+value ->
+      object {% id %}
+    | array {% id %}
+    | number {% id %}
+    | string {% id %}
+    | "true" {% function(d) { return true; } %}
+    | "false" {% function(d) { return false; } %}
+    | "null" {% function(d) { return null; } %}
+
+number -> %number {% function(d) { return parseFloat(d[0].value) } %}
+
+string -> %string {% function(d) { return JSON.parse(d[0].value) } %}
+
+pair -> key _ ":" _ value {% function(d) { return [d[0], d[4]]; } %}
+
+key -> string {% id %}
+
+_ -> null | %space {% function(d) { return null; } %}
+
+@{%
+
+function extractPair(kv, output) {
+    if(kv[0]) { output[kv[0]] = kv[1]; }
+}
+
+function extractObject(d) {
+    let output = {};
+
+    extractPair(d[2], output);
+
+    for (let i in d[3]) {
+        extractPair(d[3][i][3], output);
+    }
+
+    return output;
+}
+
+function extractArray(d) {
+    let output = [d[2]];
+
+    for (let i in d[3]) {
+        output.push(d[3][i][3]);
+    }
+
+    return output;
+}
+
+%}

benchmarks/package-lock.json

@@ -2,7 +2,7 @@
   "name": "jsonlint-benchmarks",
   "private": true,
   "scripts": {
-    "prepare": "jison -o jison/pure.js jison/pure.y jison/pure.l && jison -o jison/extended.js jison/extended.y jison/extended.l && pegjs pegjs/pure.pegjs && pegjs pegjs/extended.pegjs"
+    "prepare": "jison -o jison/pure.js jison/pure.y jison/pure.l && jison -o jison/extended.js jison/extended.y jison/extended.l && pegjs pegjs/pure.pegjs && pegjs pegjs/extended.pegjs && nearleyc nearley/purel.ne -o nearley/purel.js"
   },
   "devDependencies": {
     "benchmark": "2.1.4",
@@ -11,7 +11,9 @@
     "jison": "0.4.18",
     "json-to-ast": "2.1.0",
     "json5": "2.1.1",
+    "moo": "0.5.1",
     "myna-parser": "2.5.1",
+    "nearley": "2.19.0",
     "pegjs": "0.10.0"
   }
 }

benchmarks/package.json

@@ -20,6 +20,10 @@ const { parse: parseThis, tokenize: tokenizeThis } = require('..')
 const myna = require('myna-parser')
 require('./myna/pure')(myna)
 const mynaParse = myna.parsers.json
+const { Parser: NearleyParser, Grammar: NearleyGrammar } = require('nearley')
+const nearleyJsonGrammar = require('./nearley/pure')
+const nearleyParser = new NearleyParser(NearleyGrammar.fromCompiled(nearleyJsonGrammar));
+const nearleyOrigin = nearleyParser.save()
 
 const pkg = require('../package')
 const input = JSON.stringify(pkg, undefined, 2)
@@ -79,6 +83,11 @@ function parseCurrentTokenising () {
   tokenizeThis(input, { mode: 'json5' })
 }
 
+function parseNearley () {
+  nearleyParser.restore(nearleyOrigin)
+  nearleyParser.feed(input)
+}
+
 function parsePurePegjs () {
   pegjsParse(input)
 }
@@ -130,4 +139,5 @@ createSuite(`Parsing JSON data ${input.length} characters long using`)
   .add('the pure jison parser', parsePureJison)
   .add('the extended jison parser', parseExtendedJison)
   .add('the JSON5 parser', parseJSON5)
+  .add('the Nearley parser', parseNearley)
   .start()

benchmarks/parse.js

@@ -48,6 +48,7 @@ This is a result of the [benchmark] run by `npm run benchmarks`. The numbers sho
       the pure jison parser x 2,460 ops/sec ±0.49% (89 runs sampled)
       the extended jison parser x 2,195 ops/sec ±0.63% (88 runs sampled)
       the JSON5 parser x 1,660 ops/sec ±0.84% (90 runs sampled)
+      the Nearley parser x 1,408 ops/sec ±1.14% (85 runs sampled)
     The fastest one was the built-in parser,the standard jsonlint parser.
 
 I looked further at capabilities and licenses of the parsers.