From 016821207f1f2294dd09935a4c1d14d78ff3aed1 Mon Sep 17 00:00:00 2001
From: Akshay Nair <phenax5@gmail.com>
Date: Thu, 13 Jan 2022 21:20:23 +0530
Subject: refactor(parser): reimplements alt parser

---
 tests/parser.spec.ts | 93 +++++++++++++++++++++++++++-------------------------
 1 file changed, 49 insertions(+), 44 deletions(-)

(limited to 'tests/parser.spec.ts')

diff --git a/tests/parser.spec.ts b/tests/parser.spec.ts
index bd71509..510e5bb 100644
--- a/tests/parser.spec.ts
+++ b/tests/parser.spec.ts
@@ -4,15 +4,26 @@ import {
   whitespace,
   whitespaces0,
   delimited,
+  sepBy1,
+  symbol,
 } from '../src/parser/utils'
 import { parser } from '../src/parser'
 import { none, some } from 'fp-ts/Option'
 import { Expr, Literal } from '../src/types'
 import { jlog } from '../src/utils'
 
-const wrap = (l: any) => right([[none, l, none], ''])
+const wrap = (e: Expr) =>
+  right([[none, e, none], ''])
+const grouped = (l: Expr[]) =>
+  wrap(Expr.Group({ exprs: l }))
+const groupedAlt = (l: Expr[]) =>
+  wrap(Expr.Or({ exprs: l }))
 
 describe('Parser', () => {
+  it('should do shit', () => {
+    // jlog(parser(/ -2.05|\n2|true|\s|\T /.source))
+  })
+
   it('should do shit', () => {
     expect(digits('12901')).toEqual(right(['12901', '']))
     expect(digits('12901asas')).toEqual(right(['12901', 'asas']))
@@ -28,18 +39,19 @@ describe('Parser', () => {
     )
   })
 
-  it('should maybeshut', () => {
-    expect(parser(/^ .\s(\n)\b  \T $/.source)).toEqual(
+  it('should compount expressions', () => {
+    expect(parser(/^ .\s(\n\b)  \T $/.source)).toEqual(
       right([
         [
           some(Expr.Start()),
-          [
-            Expr.AnyItem(),
-            Expr.AnyString(),
-            Expr.Group({ exprs: [Expr.AnyNumber()] }),
-            Expr.AnyBool(),
-            Expr.Truthy(),
-          ],
+          Expr.Group({
+            exprs: [
+              Expr.AnyItem(),
+              Expr.AnyString(),
+              Expr.Group({ exprs: [Expr.AnyNumber(), Expr.AnyBool()] }),
+              Expr.Truthy(),
+            ],
+          }),
           some(Expr.End()),
         ],
         '',
@@ -50,48 +62,41 @@ describe('Parser', () => {
       right([
         [
           some(Expr.Start()),
-          [
-            Expr.ZeroOrMore({ expr: Expr.AnyString() }),
-            Expr.Optional({ expr: Expr.Truthy() }),
-            Expr.OneOrMore({ expr: Expr.AnyNumber() }),
-          ],
+          Expr.Group({
+            exprs: [
+              Expr.ZeroOrMore({ expr: Expr.AnyString() }),
+              Expr.Optional({ expr: Expr.Truthy() }),
+              Expr.OneOrMore({ expr: Expr.AnyNumber() }),
+            ],
+          }),
           some(Expr.End()),
         ],
         '',
       ]),
     )
+  })
 
+  it('should or expressions', () => {
     expect(parser(/ \s|\b\T|\n /.source)).toEqual(
-      right([
-        [
-          none,
-          [
-            Expr.Or({
-              left: Expr.AnyString(),
-              right: [
-                Expr.AnyBool(),
-                Expr.Or({
-                  left: Expr.Truthy(),
-                  right: [Expr.AnyNumber()],
-                }),
-              ],
-            }),
-          ],
-          none,
-        ],
-        '',
+      groupedAlt([
+        Expr.AnyString(),
+        Expr.Group({ exprs: [Expr.AnyBool(), Expr.Truthy()] }),
+        Expr.AnyNumber(),
       ]),
     )
   })
 
   it('object proprtyu', () => {
     expect(parser(/ [name \s\T] [age \n] /.source)).toEqual(
-      wrap([
+      grouped([
         Expr.PropertyMatch({
           name: 'name',
           expr: Expr.Group({ exprs: [Expr.AnyString(), Expr.Truthy()] }),
         }),
-        Expr.PropertyMatch({ name: 'age', expr: Expr.Group({ exprs: [Expr.AnyNumber()] }) }),
+        Expr.PropertyMatch({
+          name: 'age',
+          expr: Expr.AnyNumber(),
+        }),
       ]),
     )
   })
@@ -99,35 +104,35 @@ describe('Parser', () => {
   it('literals', () => {
     // unsigned numbers
     expect(parser(/ 0.105 /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Number(0.105))]),
+      wrap(Expr.Literal(Literal.Number(0.105))),
     )
     expect(parser(/ 9 /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Number(9))]),
+      wrap(Expr.Literal(Literal.Number(9))),
     )
     expect(parser(/ 23 /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Number(23))]),
+      wrap(Expr.Literal(Literal.Number(23))),
     )
 
     // signed numbers
     expect(parser(/ +23.025 /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Number(23.025))]),
+      wrap(Expr.Literal(Literal.Number(23.025))),
     )
     expect(parser(/ -23.025 /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Number(-23.025))]),
+      wrap(Expr.Literal(Literal.Number(-23.025))),
     )
     expect(parser(/ +23 /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Number(23))]),
+      wrap(Expr.Literal(Literal.Number(23))),
     )
     expect(parser(/ -23 /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Number(-23))]),
+      wrap(Expr.Literal(Literal.Number(-23))),
     )
 
     // boolean
     expect(parser(/ true /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Boolean(true))]),
+      wrap(Expr.Literal(Literal.Boolean(true))),
     )
     expect(parser(/ false /.source)).toEqual(
-      wrap([Expr.Literal(Literal.Boolean(false))]),
+      wrap(Expr.Literal(Literal.Boolean(false))),
     )
   })
 })
-- 
cgit v1.3.1