Merge d6c62a3 into 047b903

src/parslets/ObjectParslet.ts

@@ -71,7 +71,7 @@ export function createObjectParslet ({ objectFieldGrammar, allowKeyTypes }: {
           } else {
             break
           }
-          const type = parser.getLexer().token().type
+          const type = parser.lexer.current.type
           if (type === '}') {
             break
           }

test/FunctionParslet.spec.ts

@@ -2,6 +2,7 @@ import { expect } from 'chai'
 import { jsdocGrammar } from '../src/grammars/jsdocGrammar'
 import { createFunctionParslet } from '../src/parslets/FunctionParslet'
 import { Parser } from '../src/Parser'
+import { Lexer } from '../src/lexer/Lexer'
 
 function parse (text: string): void {
   // Replace other function parslet with one setting
@@ -14,8 +15,8 @@ function parse (text: string): void {
       allowNoReturnType: true
     })
   ]
-  const parser = new Parser({ grammar })
-  parser.parseText(text)
+  const parser = new Parser(grammar, Lexer.create(text))
+  parser.parse()
 }
 
 describe('`createFunctionParslet`', () => {

test/ObjectParslet.api.spec.ts

@@ -7,6 +7,7 @@ import { Grammar } from '../src/grammars/Grammar'
 
 import { createObjectParslet } from '../src/parslets/ObjectParslet'
 import { RootResult } from '../src/result/RootResult'
+import { Lexer } from '../src/lexer/Lexer'
 
 describe('`ObjectParslet`', () => {
   beforeEach(() => {
@@ -26,12 +27,13 @@ describe('`ObjectParslet`', () => {
       objectFieldGrammar
     })
 
-    const parser = new Parser({
-      grammar: [
+    const parser = new Parser(
+      [
         objectParslet,
         ...jsdocGrammar
-      ]
-    })
+      ],
+      Lexer.create('{abc}')
+    )
 
     const ret: unknown = undefined
 
@@ -41,7 +43,7 @@ describe('`ObjectParslet`', () => {
       ret as RootResult
     )
 
-    const rootResult = parser.parseText('{abc}')
+    const rootResult = parser.parse()
 
     expect(rootResult).to.deep.equal({
       elements: [

test/ParameterListParslet.spec.ts

@@ -0,0 +1,37 @@
+import { createFunctionParslet } from '../src/parslets/FunctionParslet'
+import { Lexer } from '../src/lexer/Lexer'
+import { expect } from 'chai'
+import { Parser } from '../src/Parser'
+import { createParameterListParslet } from '../src/parslets/ParameterListParslet'
+import { createNameParslet } from '../src/parslets/NameParslet'
+import { createObjectParslet } from '../src/parslets/ObjectParslet'
+import { parenthesisParslet } from '../src/parslets/ParenthesisParslet'
+
+describe('ParameterListParslet', () => {
+  it('rethrows errors', () => {
+    const parser = new Parser(
+      [
+        createFunctionParslet({
+          allowWithoutParenthesis: false,
+          allowNamedParameters: undefined,
+          allowNoReturnType: true
+        }),
+        createParameterListParslet({
+          allowTrailingComma: false
+        }),
+        createNameParslet({
+          allowedAdditionalTokens: []
+        }),
+        createObjectParslet({
+          allowKeyTypes: false,
+          objectFieldGrammar: []
+        }),
+        parenthesisParslet
+      ],
+      Lexer.create('function(a, b, ")')
+    )
+    expect(() => {
+      parser.parse()
+    }).to.throw('Unterminated String')
+  })
+})

test/Parser.spec.ts

@@ -4,13 +4,12 @@ import { Parser } from '../src/Parser'
 import { NoParsletFoundError, EarlyEndOfParseError } from '../src/errors'
 
 import { typescriptGrammar } from '../src/grammars/typescriptGrammar'
+import { Lexer } from '../src/lexer/Lexer'
 
 describe('Parser', () => {
   it('should consume an array of tokens', () => {
-    const parser = new Parser({
-      grammar: typescriptGrammar
-    })
-    parser.parseText('[test]')
+    const parser = new Parser(typescriptGrammar, Lexer.create('[test]'))
+    parser.parse()
 
     const twoTokens = parser.consume(['[', 'Identifier'])
     const finalTokens = parser.consume([']', 'EOF'])
@@ -20,13 +19,11 @@ describe('Parser', () => {
   })
 
   it('should return token of error with `NoParsletFoundError.getToken`', () => {
-    const parser = new Parser({
-      grammar: typescriptGrammar
-    })
+    const parser = new Parser(typescriptGrammar, Lexer.create('{'))
 
     let error
     try {
-      parser.parseText('{')
+      parser.parse()
     } catch (err) {
       error = err
     }
@@ -44,13 +41,11 @@ describe('Parser', () => {
   })
 
   it('should return token of error with `EarlyEndOfParseError.getToken`', () => {
-    const parser = new Parser({
-      grammar: typescriptGrammar
-    })
+    const parser = new Parser(typescriptGrammar, Lexer.create('name]'))
 
     let error
     try {
-      parser.parseText('name]')
+      parser.parse()
     } catch (err) {
       error = err
     }

test/SpecialTypesParslet.spec.ts

@@ -14,10 +14,7 @@ class BadParser extends Parser {
 describe('specialTypesParslet', () => {
   it('Errs with bad parser `consume()`', () => {
     expect(() => {
-      const parser = new BadParser({
-        grammar: typescriptGrammar
-      })
-      parser.parseText('null')
+      const parser = new BadParser(typescriptGrammar, 'null')
       specialTypesParslet(parser, Precedence.ALL, null)
     }).to.throw('Unacceptable token:')
   })

test/api.errors.spec.ts

@@ -47,17 +47,18 @@ describe('API errors', () => {
           // Exclude name parslet
           pathGrammar: namePathGrammar
         })
-        const parser = new Parser({
-          grammar: [
+        const parser = new Parser(
+          [
             // These are all we need here
             namePathParslet,
             createNameParslet({
               allowedAdditionalTokens: []
             })
-          ]
-        })
+          ],
+          'aaa.module:bbb'
+        )
 
-        parser.parseText('aaa.module:bbb')
+        parser.parse()
       }).to.throw("Unexpected type: 'JsdocTypeSpecialNamePath'. Message: Type 'JsdocTypeSpecialNamePath' is only allowed with specialType 'event'")
     })
 
@@ -78,17 +79,17 @@ describe('API errors', () => {
           // Exclude name parslet
           pathGrammar: namePathGrammar
         })
-        const parser = new Parser({
-          grammar: [
+        const parser = new Parser(
+          [
             // These are all we need here
             namePathParslet,
             createNameParslet({
               allowedAdditionalTokens: []
             })
-          ]
-        })
-
-        parser.parseText('aaa.null')
+          ],
+          'aaa.null'
+        )
+        parser.parse()
       }).to.throw("Unexpected type: 'JsdocTypeNull'. Message: Expecting 'JsdocTypeName', 'JsdocTypeNumber', 'JsdocStringValue' or 'JsdocTypeSpecialNamePath")
     })
   })

test/lexer.spec.ts

@@ -141,22 +141,13 @@ describe('lexer', () => {
     ])
   })
 
-  it('should throw when invoking token without first advancing', () => {
-    const lexer = new Lexer()
-    expect(() => {
-      lexer.token()
-    }).to.throw('Lexer not lexing')
-  })
-
   it('should obtain last token', () => {
-    const text = '(null)'
-    const lexer = new Lexer()
-    lexer.lex(text)
-    const token1 = lexer.token()
-    lexer.advance()
-    const token2 = lexer.token()
-    lexer.advance()
-    const token3 = lexer.last() as Token
+    let lexer = Lexer.create('(null)')
+    const token1 = lexer.current
+    lexer = lexer.advance()
+    const token2 = lexer.current
+    lexer = lexer.advance()
+    const token3 = lexer.previous as Token
     expect(token1.text).to.equal('(')
     expect(token2.text).to.equal('null')
     expect(token3.text).to.equal('null')