Merge pull request #178 from /issues/177

Fixes #177 adds seqObj

API.md

@@ -178,13 +178,14 @@ Returns a parser that doesn't consume any input, and yields `result`.
 
 This is an alias for `Parsimmon.succeed(result)`.
 
+## Parsimmon.formatError(string, error)
+
+Takes the `string` passed to `parser.parse(string)` and the `error` returned from `parser.parse(string)` and turns it into a human readable error message string. Note that there are certainly better ways to format errors, so feel free to write your own.
+
 ## Parsimmon.seq(p1, p2, ...pn)
 
 Accepts any number of parsers and returns a new parser that expects them to match in order, yielding an array of all their results.
 
-## Parsimmon.formatError(string, error)
-
-Takes the `string` passed to `parser.parse(string)` and the `error` returned from `parser.parse(string)` and turns it into a human readable error message string. Note that there are certainly better ways to format errors, so feel free to write your own.
 
 ## Parsimmon.seqMap(p1, p2, ...pn, function(r1, r2, ...rn))
 
@@ -204,6 +205,38 @@ Parsimmon.seqMap(
 ).parse('a+x')
 ```
 
+## Parsimmon.seqObj(...args)
+
+Similar to `Parsimmon.seq(...parsers)`, but yields an object of results named based on arguments.
+
+Takes one or more arguments, where each argument is either a parser or a named parser pair (`[stringKey, parser]`).
+
+Requires at least one named parser.
+
+All named parser keys must be unique.
+
+Example:
+
+```js
+var _ = Parsimmon.optWhitespace;
+var identifier = Parsimmon.regexp(/[a-z_][a-z0-9_]*/i);
+var lparen = Parsimmon.string('(');
+var rparen = Parsimmon.string(')');
+var comma = Parsimmon.string(',');
+var functionCall =
+ Parsimmon.seqObj(
+ ['function', identifier],
+ lparen,
+ ['arguments', identifier.trim(_).sepBy(comma)],
+ rparen
+ );
+functionCall.tryParse('foo(bar, baz, quux)');
+// => { function: 'foo',
+// arguments: [ 'bar', 'baz', 'quux' ] }
+```
+
+Tip: Combines well with `.node(name)` for a full-featured AST node.
+
 ## Parsimmon.alt(p1, p2, ...pn)
 
 Accepts any number of parsers, yielding the value of the first one that succeeds, backtracking in between.

CHANGELOG.md

@@ -1,5 +1,11 @@
+## version 1.6.0 (2017-06-26)
+
+* Adds `Parsimmon.seqObj(...args)`
+
 ## version 1.5.0 (2017-06-17)
 
+NOTE: Code was completed on 2017-06-17, but due to human error, was not published on npm until 2017-06-26.
+
 * Adds `parser.sepBy(separator)` alias for `Parsimmon.sepBy(parser, separator)`
 * Adds `parser.sepBy1(separator)` alias for `Parsimmon.sepBy1(parser, separator)`
 * Adds `Parsimmon.range(begin, end)`

examples/python-ish.js

@@ -51,14 +51,16 @@ let Pythonish = P.createLanguage({
  // block, and require that every other statement has the same exact string of
  // indentation in front of it.
  Block: r =>
- P.seq(
- P.string('block:\n').then(P.regexp(/[ ]+/)),
- r.Statement
+ P.seqObj(
+ P.string('block:'),
+ P.string('\n'),
+ ['indent', P.regexp(/[ ]+/)],
+ ['statement', r.Statement]
  ).chain(args => {
  // `.chain` is called after a parser succeeds. It returns the next parser
  // to use for parsing. This allows subsequent parsing to be dependent on
  // previous text.
- let [indent, statement] = args;
+ let {indent, statement} = args;
  let indentSize = indent.length;
  let currentSize = indentPeek();
  // Indentation must be deeper than the current block context. Otherwise

examples/seqobj.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// Run me with Node to see my output!
+
+let util = require('util');
+let P = require('../');
+
+///////////////////////////////////////////////////////////////////////
+
+let Lang = P.createLanguage({
+
+ _: () => P.optWhitespace,
+
+ LParen: () => P.string('('),
+ RParen: () => P.string(')'),
+ Comma: () => P.string(','),
+ Dot: () => P.string('.'),
+
+ Identifier: () => P.letters.node('Identifier'),
+
+ MethodCall: r =>
+ P.seqObj(
+ ['receiver', r.Identifier],
+ r.Dot.trim(r._),
+ ['method', r.Identifier],
+ r.LParen,
+ ['arguments', r.Identifier.trim(r._).sepBy(r.Comma)],
+ r.RParen
+ ).node('MethodCall'),
+
+});
+
+///////////////////////////////////////////////////////////////////////
+
+let text = 'console.log(bar, baz, quux)';
+
+function prettyPrint(x) {
+ let opts = {depth: null, colors: 'auto'};
+ let s = util.inspect(x, opts);
+ console.log(s);
+}
+
+let ast = Lang.MethodCall.tryParse(text);
+prettyPrint(ast);

package.json

@@ -1,6 +1,6 @@
 {
  "name": "parsimmon",
- "version": "1.5.0",
+ "version": "1.6.0",
  "description": "A monadic LL(infinity) parser combinator library",
  "keywords": [
  "parsing",

src/parsimmon.js

@@ -15,6 +15,10 @@ function isParser(obj) {
  return obj instanceof Parsimmon;
 }
 
+function isArray(x) {
+ return {}.toString.call(x) === '[object Array]';
+}
+
 function makeSuccess(index, value) {
  return {
  status: true,
@@ -107,7 +111,7 @@ function assertParser(p) {
 
 // TODO[ES5]: Switch to Array.isArray eventually.
 function assertArray(x) {
- if ({}.toString.call(x) !== '[object Array]') {
+ if (!isArray(x)) {
  throw new Error('not an array: ' + x);
  }
 }
@@ -203,6 +207,65 @@ function seq() {
  });
 }
 
+function seqObj() {
+ var seenKeys = {};
+ var totalKeys = 0;
+ var parsers = [].slice.call(arguments);
+ var numParsers = parsers.length;
+ for (var j = 0; j < numParsers; j += 1) {
+ var p = parsers[j];
+ if (isParser(p)) {
+ continue;
+ }
+ if (isArray(p)) {
+ var isWellFormed =
+ p.length === 2 &&
+ typeof p[0] === 'string' &&
+ isParser(p[1]);
+ if (isWellFormed) {
+ var key = p[0];
+ if (seenKeys[key]) {
+ throw new Error('seqObj: duplicate key ' + key);
+ }
+ seenKeys[key] = true;
+ totalKeys++;
+ continue;
+ }
+ }
+ throw new Error(
+ 'seqObj arguments must be parsers or ' +
+ '[string, parser] array pairs.'
+ );
+ }
+ if (totalKeys === 0) {
+ throw new Error('seqObj expects at least one named parser, found zero');
+ }
+ return Parsimmon(function(input, i) {
+ var result;
+ var accum = {};
+ for (var j = 0; j < numParsers; j += 1) {
+ var name;
+ var parser;
+ if (isArray(parsers[j])) {
+ name = parsers[j][0];
+ parser = parsers[j][1];
+ } else {
+ name = null;
+ parser = parsers[j];
+ }
+ result = mergeReplies(parser._(input, i), result);
+ if (!result.status) {
+ return result;
+ }
+ if (name) {
+ accum[name] = result.value;
+ }
+ i = result.index;
+ }
+ return mergeReplies(makeSuccess(i, accum), result);
+ });
+}
+
 function seqMap() {
  var args = [].slice.call(arguments);
  if (args.length === 0) {
@@ -720,6 +783,7 @@ Parsimmon.sepBy = sepBy;
 Parsimmon.sepBy1 = sepBy1;
 Parsimmon.seq = seq;
 Parsimmon.seqMap = seqMap;
+Parsimmon.seqObj = seqObj;
 Parsimmon.string = string;
 Parsimmon.succeed = succeed;
 Parsimmon.takeWhile = takeWhile;

test/core/seqObj.test.js

@@ -0,0 +1,65 @@
+'use strict';
+
+suite('Parsimmon.seqObj', function() {
+
+ test('does not accept duplicate keys', function() {
+ assert.throws(function() {
+ Parsimmon.seqObj(
+ ['a', Parsimmon.of(1)],
+ ['b', Parsimmon.of(2)],
+ ['a', Parsimmon.of(3)]
+ );
+ });
+ });
+
+ test('requires at least one key', function() {
+ assert.throws(function() {
+ Parsimmon.seqObj();
+ });
+ });
+
+ test('every key is present in the result object', function() {
+ var parser = Parsimmon.seqObj(
+ ['a', Parsimmon.of(1)],
+ ['b', Parsimmon.of(2)],
+ ['c', Parsimmon.of(3)]
+ );
+ var result = parser.tryParse('');
+ assert.deepStrictEqual(result, {
+ a: 1,
+ b: 2,
+ c: 3,
+ });
+ });
+
+ test('every parser is used', function() {
+ var parser = Parsimmon.seqObj(
+ Parsimmon.string('a'),
+ ['b', Parsimmon.string('b')],
+ Parsimmon.string('c'),
+ ['d', Parsimmon.string('d')],
+ Parsimmon.string('e')
+ );
+ var result = parser.tryParse('abcde');
+ assert.deepStrictEqual(result, {
+ b: 'b',
+ d: 'd',
+ });
+ });
+
+ test('named parser arrays are formed properly', function() {
+ assert.throws(function() {
+ Parsimmon.seqObj([]);
+ });
+ assert.throws(function() {
+ Parsimmon.seqObj(['a', Parsimmon.of(1), 'oops extra']);
+ });
+ assert.throws(function() {
+ Parsimmon.seqObj([123, Parsimmon.of(1)]);
+ });
+ assert.throws(function() {
+ Parsimmon.seqObj(['cool', 'potato']);
+ });
+ });
+
+});