feat: add descriptions to parsers

fixes #114

src/__tests__/descriptions.test.js

@@ -0,0 +1,38 @@
+// @flow
+
+const fs = require('fs')
+const path = require('path')
+
+const exclude = [
+  '__tests__',
+  'abstract',
+  'pipe',
+  'tuple',
+  'primitives',
+  'operand.js',
+  'listCore.js',
+  'crap.js',
+  'functionCall.js',
+  'parser.js',
+  'primitive.js',
+  'value.js',
+  'section.js',
+  'projectable.js',
+  'program.js'
+]
+const files = fs
+  .readdirSync(path.join(__dirname, '..', 'parsers'))
+  .filter((item: string): boolean => !exclude.includes(item))
+
+describe('descriptions', () => {
+  files.forEach((fileName: string) => {
+    const parserName = fileName.slice(0, -3)
+    const moduleName = `../parsers/${parserName}`
+    // $FlowFixMe
+    const parser = require(moduleName).default._
+    const options = parser('¡').expected
+    it(parserName, () => {
+      expect(options[0]).toEqual(parserName)
+    })
+  })
+})

src/parsers/abstract/binaryOperator.js

@@ -7,28 +7,29 @@ import type { NodeType, ParserType } from '../../types'
 
 const BinaryOperatorParser = (
   OperandParser: ParserType,
-  OperatorParser: ParserType
+  OperatorParser: ParserType,
+  description: string
 ): ParserType =>
   P.lazy((): mixed => {
-    const OperatorParser_ = OperatorParser.node(
-      'primitive'
-    )
+    const OperatorParser_ = OperatorParser.node('primitive')
     return P.seq(
       OperandParser,
       P.seq(crap.then(OperatorParser_), crap.then(OperandParser)).many()
-    ).map(
-      (value: [NodeType, Array<NodeType>]): NodeType =>
-        value[1].length > 0
-          ? {
-            name: 'binaryOperation',
-            value: value[1].reduce(
-              (a: Array<NodeType>, b: NodeType): Array<NodeType> =>
-                a.concat(b),
-              [value[0]]
-            )
-          }
-          : value[0]
     )
+      .map(
+        (value: [NodeType, Array<NodeType>]): NodeType =>
+          value[1].length > 0
+            ? {
+              name: 'binaryOperation',
+              value: value[1].reduce(
+                (a: Array<NodeType>, b: NodeType): Array<NodeType> =>
+                  a.concat(b),
+                [value[0]]
+              )
+            }
+            : value[0]
+      )
+      .desc(description)
   })
 
 export default BinaryOperatorParser

src/parsers/abstract/listLike.js

@@ -20,3 +20,4 @@ export default ({
     .wrap(P.string(open), P.string(close))
     .map((value: {value: ListCoreNodeType}): ListCoreNodeType => value.value)
     .node(name)
+    .desc(name)

src/parsers/additive.js

@@ -5,4 +5,8 @@ import P from 'parsimmon'
 import MultiplicativeParser from './multiplicative'
 import BinaryOperatorParser from './abstract/binaryOperator'
 
-export default BinaryOperatorParser(MultiplicativeParser, P.regexp(/[+-]/))
+export default BinaryOperatorParser(
+  MultiplicativeParser,
+  P.regexp(/[+-]/),
+  'additive'
+)

src/parsers/assignment.js

@@ -37,3 +37,4 @@ export default P.seq(
     })
   )
   .node('assignment')
+  .desc('assignment')

src/parsers/boolean1.js

@@ -5,4 +5,8 @@ import P from 'parsimmon'
 import AdditiveParser from './additive'
 import BinaryOperatorParser from './abstract/binaryOperator'
 
-export default BinaryOperatorParser(AdditiveParser, P.regexp(/[<>]=?/))
+export default BinaryOperatorParser(
+  AdditiveParser,
+  P.regexp(/[<>]=?/),
+  'boolean1'
+)

src/parsers/boolean2.js

@@ -7,5 +7,6 @@ import BinaryOperatorParser from './abstract/binaryOperator'
 
 export default BinaryOperatorParser(
   Boolean1,
-  P.regexp(/[=!]=/).map((x: string): string => x + '=')
+  P.regexp(/[=!]=/).map((x: string): string => x + '='),
+  'boolean2'
 )

src/parsers/boolean3.js

@@ -9,5 +9,6 @@ export default BinaryOperatorParser(
   Boolean2,
   P.regexp(/(\|\||&&|or|and)/).map(
     (x: string): string => (x === 'or' ? '||' : x === 'and' ? '&&' : x)
-  )
+  ),
+  'boolean3'
 )

src/parsers/identifier.js

@@ -5,7 +5,9 @@ import type { IdentifierNodeType } from '../types'
 
 export default P.regexp(
   /((?!null|false|true)[a-zA-Z][0-9a-zA-Z_$]*|(null|false|true)[0-9a-zA-Z_$])/
-).map((value: string): IdentifierNodeType => ({
-  name: 'identifier',
-  value
-}))
+)
+  .map((value: string): IdentifierNodeType => ({
+    name: 'identifier',
+    value
+  }))
+  .desc('identifier')

src/parsers/inputProp.js

@@ -3,9 +3,9 @@
 import P from 'parsimmon'
 import type { InputPropNodeType } from '../types'
 
-export default P.regexp(/\.[$A-Z_][0-9A-Z_$]*/i).map(
-  (value: string): InputPropNodeType => ({
+export default P.regexp(/\.[$A-Z_][0-9A-Z_$]*/i)
+  .map((value: string): InputPropNodeType => ({
     name: 'inputProp',
     value
-  })
-)
+  }))
+  .desc('inputProp')

src/parsers/lambda.js

@@ -33,3 +33,4 @@ export default P.alt(
 )
   .trim(crap)
   .node('lambda')
+  .desc('lambda')

src/parsers/multiplicative.js

@@ -8,5 +8,6 @@ import BinaryOperatorParser from './abstract/binaryOperator'
 
 export default BinaryOperatorParser(
   P.alt(OperandParser, UnaryOperatorParser),
-  P.regexp(/[*/%]/)
+  P.regexp(/[*/%]/),
+  'multiplicative'
 )

src/parsers/parentheses.js

@@ -6,12 +6,10 @@ import type { ParenthesesNodeType, ParserType } from '../types'
 
 export default P.lazy((): ParserType => {
   const ProgramParser = require('./program').default
-  return P.seq(
-    P.string('('),
-    ProgramParser,
-    P.string(')')
-  ).map((value: [mixed, ParenthesesNodeType, mixed]): ParenthesesNodeType => ({
-    name: 'parentheses',
-    value: value[1]
-  }))
+  return P.seq(P.string('('), ProgramParser, P.string(')'))
+    .map((value: [mixed, ParenthesesNodeType, mixed]): ParenthesesNodeType => ({
+      name: 'parentheses',
+      value: value[1]
+    }))
+    .desc('parentheses')
 })

src/parsers/projection.js

@@ -87,7 +87,7 @@ const ProjectionParser = P.lazy((): mixed => {
     P.alt(ProjectionParser, PropertyParser)
       .skip(crap)
       .atLeast(1)
-  ).map(unpack)
+  ).map(unpack).desc('projection')
 })
 
 export default ProjectionParser

src/parsers/ternary.js

@@ -24,4 +24,5 @@ export default P.lazy((): ParserType => {
       ]): TernaryNodeValueType => ({ left, middle, right })
     )
     .node('ternary')
+    .desc('ternary')
 })

src/parsers/unaryOperator.js

@@ -15,21 +15,23 @@ const UnaryOperatorParser = P.lazy((): ParserType => {
     .trim(crap)
     .node('primitive')
   const OperandParser = require('./operand').default
-  return P.seq(OperatorParser.atLeast(1), OperandParser).map(
-    ([operators, operand]: [Array<PrimitiveNodeType>, NodeType]): NodeType =>
-      operators.length > 0
-        ? operators.reduce(
-          (a: NodeType, b: PrimitiveNodeType): UnaryOperationNodeType => ({
-            name: 'unaryOperation',
-            value: {
-              operator: b,
-              operand: a
-            }
-          }),
-          operand
-        )
-        : operand
-  )
+  return P.seq(OperatorParser.atLeast(1), OperandParser)
+    .map(
+      ([operators, operand]: [Array<PrimitiveNodeType>, NodeType]): NodeType =>
+        operators.length > 0
+          ? operators.reduce(
+            (a: NodeType, b: PrimitiveNodeType): UnaryOperationNodeType => ({
+              name: 'unaryOperation',
+              value: {
+                operator: b,
+                operand: a
+              }
+            }),
+            operand
+          )
+          : operand
+    )
+    .desc('unaryOperator')
 })
 
 export default UnaryOperatorParser

src/parsers/variable.js

@@ -11,3 +11,4 @@ export default P.string('$')
     name: 'variable',
     value: value && value.length ? `$${value[0].value}` : '$'
   }))
+  .desc('variable')