Merge pull request #188 from jneen/topic/test-coverage

Fixes #187 regexp group out of range; 100% tests

.gitignore

@@ -3,3 +3,4 @@ node_modules
 npm-*.log
 .nyc_output
 coverage
+.DS_Store

API.md

@@ -142,7 +142,7 @@ Parsimmon.test(function(c) {
 });
 ```
 
-## Parsimmon.regexp(regexp, group=0)
+## Parsimmon.regexp(regexp)
 
 Returns a parser that looks for a match to the regexp and yields the entire text matched. The regexp will always match starting at the current parse location. The regexp may only use the following flags: `imu`. Any other flag will result in an error being thrown.
 

CHANGELOG.md

@@ -1,3 +1,8 @@
+## version 1.6.1 (2017-07-01)
+
+* **100% unit test coverage!** This does not mean bugs won't exist, but it keeps us much safer against regressions in the future.
+* **BUGFIX:** `Parsimmon.regexp(regexp, group)` will now correctly fail to parse if the `group` number is out of range for the `regexp` number of groups. This worked correctly in the past, but was broken during a minor code clean up due to missing tests.
+
 ## version 1.6.0 (2017-06-26)
 
 * Adds `Parsimmon.seqObj(...args)`

package.json

@@ -1,6 +1,6 @@
 {
   "name": "parsimmon",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "A monadic LL(infinity) parser combinator library",
   "keywords": [
     "parsing",
@@ -38,7 +38,8 @@
     "precoverage": "npm run test",
     "coverage": "nyc report --reporter=text-lcov | coveralls",
     "pretest": "npm run lint",
-    "test": "nyc node_modules/.bin/mocha -i src --ui tdd --reporter dot test/setup.js test/core/*.test.js test/laws/*.test.js",
+    "test": "nyc --reporter=lcov npm run test:mocha",
+    "test:mocha": "mocha -i src --ui tdd --reporter dot test/setup.js test/core/*.test.js test/laws/*.test.js",
     "watch:test": "mocha --ui tdd --reporter min --watch test/setup.js test/core/*.test.js test/laws/*.test.js"
   }
 }

src/parsimmon.js

@@ -590,11 +590,14 @@ function regexp(re, group) {
   return Parsimmon(function(input, i) {
     var match = anchored.exec(input.slice(i));
     if (match) {
-      var fullMatch = match[0];
-      var groupMatch = match[group];
-      if (groupMatch !== null) {
+      if (0 <= group && group <= match.length) {
+        var fullMatch = match[0];
+        var groupMatch = match[group];
         return makeSuccess(i + fullMatch.length, groupMatch);
       }
+      return makeFailure(
+        'valid match group (0 to ' + match.length + ') in ' + expected
+      );
     }
     return makeFailure(i, expected);
   });

test/.eslintrc

@@ -6,6 +6,8 @@
     "Parsimmon": true,
     "assert": true,
     "suite": true,
+    "setup": true,
+    "teardown": true,
     "test": true
   }
 }

test/core/alt.test.js

@@ -38,4 +38,7 @@ test('Parsimmon.alt', function(){
   assert.throws(function() {
     Parsimmon.alt('not a parser');
   });
+
+
+  assert.strictEqual(Parsimmon.alt().parse('').status, false);
 });

test/core/constructor.test.js

@@ -1,28 +1,48 @@
 'use strict';
 
-test('Parsimmon()', function() {
-  var good = 'just a Q';
-  var bad = 'all I wanted was a Q';
-  var justQ = Parsimmon(function(str, i) {
-    if (str.charAt(i) === 'Q') {
-      return Parsimmon.makeSuccess(i + 1, good);
-    } else {
-      return Parsimmon.makeFailure(i, bad);
-    }
-  });
-  var result1 = justQ.parse('Q');
-  var result2 = justQ.parse('x');
-  assert.deepEqual(result1, {
-    status: true,
-    value: good,
+suite('Parsimmon()', function() {
+
+  test('should work in general', function() {
+    var good = 'just a Q';
+    var bad = 'all I wanted was a Q';
+    var justQ = Parsimmon(function(str, i) {
+      if (str.charAt(i) === 'Q') {
+        return Parsimmon.makeSuccess(i + 1, good);
+      } else {
+        return Parsimmon.makeFailure(i, bad);
+      }
+    });
+    var result1 = justQ.parse('Q');
+    var result2 = justQ.parse('x');
+    assert.deepEqual(result1, {
+      status: true,
+      value: good,
+    });
+    assert.deepEqual(result2, {
+      status: false,
+      index: {
+        offset: 0,
+        line: 1,
+        column: 1
+      },
+      expected: [bad]
+    });
   });
-  assert.deepEqual(result2, {
-    status: false,
-    index: {
-      offset: 0,
-      line: 1,
-      column: 1
-    },
-    expected: [bad]
+
+  test('unsafeUnion works on poorly formatted custom parser', function() {
+    var p1 = Parsimmon.string('a').or(Parsimmon.string('b'));
+    var p2 = Parsimmon(function(str, i) {
+      return {
+        status: false,
+        index: -1,
+        value: null,
+        furthest: i,
+        expected: []
+      };
+    });
+    var p3 = Parsimmon.alt(p2, p1);
+    var result = p3.parse('x');
+    assert.deepStrictEqual(result.expected, ['\'a\'', '\'b\'']);
   });
+
 });

test/core/createLanguage.test.js

@@ -2,6 +2,14 @@
 
 suite('Parsimmon.createLanguage', function() {
 
+  setup(function() {
+    Object.prototype.NASTY = 'dont extend Object.prototype please';
+  });
+
+  teardown(function() {
+    delete Object.prototype.NASTY;
+  });
+
   test('should return an object of parsers', function() {
     var lang = Parsimmon.createLanguage({
       a: function() {
@@ -29,6 +37,16 @@ suite('Parsimmon.createLanguage', function() {
     lang.Parentheses.tryParse('(((())))');
   });
 
+  test('should ignore non-own properties', function() {
+    var obj = Object.create({
+      foo: function() {
+        return Parsimmon.of(1);
+      }
+    });
+    var lang = Parsimmon.createLanguage(obj);
+    assert.strictEqual(lang.foo, undefined);
+  });
+
   test('should allow indirect recursion in parsers', function() {
     var lang = Parsimmon.createLanguage({
       Value: function(r) {

test/core/custom.test.js

@@ -58,4 +58,5 @@ suite('Parsimmon.custom', function(){
 
     assert.deepEqual(parser.parse('acccccb'), {status: true, value: 'acccccb'});
   });
+
 });

test/core/formatError.test.js

@@ -1,14 +1,35 @@
 'use strict';
 
-test('Parsimmon.formatError', function() {
-  var parser =
-    Parsimmon.alt(
-      Parsimmon.fail('a'),
-      Parsimmon.fail('b'),
-      Parsimmon.fail('c')
-    );
-  var expectation = 'expected one of a, b, c, got the end of the input';
-  var input = '';
-  var answer = Parsimmon.formatError(input, parser.parse(input));
-  assert.deepEqual(answer, expectation);
+suite('formatError', function() {
+
+  test('end of input', function() {
+    var parser =
+      Parsimmon.alt(
+        Parsimmon.fail('a'),
+        Parsimmon.fail('b'),
+        Parsimmon.fail('c')
+      );
+    var expectation = 'expected one of a, b, c, got the end of the input';
+    var input = '';
+    var answer = Parsimmon.formatError(input, parser.parse(input));
+    assert.deepEqual(answer, expectation);
+  });
+
+  test('middle of input', function() {
+    var parser =
+      Parsimmon.seq(
+        Parsimmon.string('1'),
+        Parsimmon.alt(
+          Parsimmon.fail('a'),
+          Parsimmon.fail('b'),
+          Parsimmon.fail('c')
+        )
+      );
+    var expectation =
+      'expected one of a, b, c at line 1 column 2, got \'...x11111111111...\'';
+    var input = '1x1111111111111111111111111111';
+    var answer = Parsimmon.formatError(input, parser.parse(input));
+    assert.deepEqual(answer, expectation);
+  });
+
 });

test/core/noneOf.test.js

@@ -0,0 +1,19 @@
+'use strict';
+
+suite('noneOf', function() {
+
+  test('matches EVERYTHING BUT the characters specified', function() {
+    var parser = Parsimmon.noneOf('abc');
+    var a = 'a'.charCodeAt(0);
+    var c = 'c'.charCodeAt(0);
+    for (var i = 0; i < 65535; i++) {
+      var s = String.fromCharCode(i);
+      if (a <= i && i <= c) {
+        assert.strictEqual(parser.parse(s).status, false);
+      } else {
+        assert.strictEqual(parser.parse(s).status, true);
+      }
+    }
+  });
+
+});

test/core/oneOf.test.js

@@ -0,0 +1,19 @@
+'use strict';
+
+suite('oneOf', function() {
+
+  test('matches ONLY the characters specified', function() {
+    var parser = Parsimmon.oneOf('abc');
+    var a = 'a'.charCodeAt(0);
+    var c = 'c'.charCodeAt(0);
+    for (var i = 0; i < 65535; i++) {
+      var s = String.fromCharCode(i);
+      if (a <= i && i <= c) {
+        assert.strictEqual(parser.parse(s).status, true);
+      } else {
+        assert.strictEqual(parser.parse(s).status, false);
+      }
+    }
+  });
+
+});

test/core/parse.test.js

@@ -17,4 +17,13 @@ suite('.parse', function() {
     assert.deepEqual(result.expected, ['a', 'b', 'c']);
   });
 
+  test('throws when given a non-string argument', function() {
+    assert.throws(function() {
+      Parsimmon.of('kaboom').parse(0);
+    });
+    assert.throws(function() {
+      Parsimmon.of('kaboom').parse();
+    });
+  });
+
 });

test/core/regexp.test.js

@@ -43,9 +43,11 @@ suite('Parsimmon.regexp', function() {
     var parser0 = Parsimmon.regexp(/(\w)(\d)/, 0);
     var parser1 = Parsimmon.regexp(/(\w)(\d)/, 1);
     var parser2 = Parsimmon.regexp(/(\w)(\d)/, 2);
-    assert.equal(parser0.parse('a1').value, 'a1');
-    assert.equal(parser1.parse('a1').value, 'a');
-    assert.equal(parser2.parse('a1').value, '1');
+    var parser3 = Parsimmon.regexp(/(\w)(\d)/, 8);
+    assert.strictEqual(parser0.parse('a1').value, 'a1');
+    assert.strictEqual(parser1.parse('a1').value, 'a');
+    assert.strictEqual(parser2.parse('a1').value, '1');
+    assert.strictEqual(parser3.parse('a1').status, false);
   });
 
 });

test/core/seqObj.test.js

@@ -32,6 +32,17 @@ suite('Parsimmon.seqObj', function() {
     });
   });
 
+
+  test('every parser is used', function() {
+    var parser = Parsimmon.seqObj(
+      ['a', Parsimmon.of(1)],
+      ['b', Parsimmon.of(2)],
+      ['c', Parsimmon.fail('oopsy')]
+    );
+    var result = parser.parse('');
+    assert.strictEqual(result.status, false);
+  });
+
   test('every parser is used', function() {
     var parser = Parsimmon.seqObj(
       Parsimmon.string('a'),
@@ -60,6 +71,9 @@ suite('Parsimmon.seqObj', function() {
     assert.throws(function() {
       Parsimmon.seqObj(['cool', 'potato']);
     });
+    assert.throws(function() {
+      Parsimmon.seqObj(0);
+    });
   });
 
 });