summaryrefslogtreecommitdiff
path: root/tests/parser.spec.ts
blob: 4db0894ec0dedde447e052ebd5125e2685c3d75c (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
import { left, right } from 'fp-ts/Either'
import {
  integer,
  whitespace,
  whitespaces0,
  delimited,
  many1,
  satifyChar,
} from '../src/parser/utils'
import { parser, propertyName } from '../src/parser'
import { none, some } from 'fp-ts/Option'
import { Expr } from '../src/types'

const plog = (x: any) => console.log(JSON.stringify(x, null, 2))

describe('Foobar', () => {
  it('should do shit', () => {
    expect(integer('12901')).toEqual(right([12901, '']))
    expect(integer('12901asas')).toEqual(right([12901, 'asas']))
    expect(whitespace(' ')).toEqual(right([' ', '']))
    expect(whitespace('\n')).toEqual(right(['\n', '']))
    expect(whitespace('a')).toEqual(left(['unable to match', 'a']))

    expect(delimited(whitespaces0, integer, whitespaces0)(' 20 ')).toEqual(
      right([20, '']),
    )
    expect(delimited(whitespaces0, integer, whitespaces0)(' 2 0 ')).toEqual(
      right([2, '0 ']),
    )
  })

  it('should maybeshut', () => {
    expect(parser(/^ .\s(\n)\b  \T $/.source)).toEqual(
      right([
        [
          some(Expr.Start(null)),
          [
            Expr.AnyItem(null),
            Expr.AnyString(null),
            Expr.Group({ exprs: [Expr.AnyNumber(null)] }),
            Expr.AnyBool(null),
            Expr.Truthy(null),
          ],
          some(Expr.End(null)),
        ],
        '',
      ]),
    )

    expect(parser(/^ \s* \T? \n+ $/.source)).toEqual(
      right([
        [
          some(Expr.Start(null)),
          [
            Expr.ZeroOrMore({ expr: Expr.AnyString(null) }),
            Expr.Optional({ expr: Expr.Truthy(null) }),
            Expr.OneOrMore({ expr: Expr.AnyNumber(null) }),
          ],
          some(Expr.End(null)),
        ],
        '',
      ]),
    )

    expect(parser(/ \s|\b\T|\n /.source)).toEqual(
      right([
        [
          none,
          [
            Expr.Or({
              left: Expr.AnyString(null),
              right: [
                Expr.AnyBool(null),
                Expr.Or({
                  left: Expr.Truthy(null),
                  right: [Expr.AnyNumber(null)],
                }),
              ],
            }),
          ],
          none,
        ],
        '',
      ]),
    )
  })

  it('object proprtyu', () => {
    expect(parser(/ [name \s\T] [age \n] /.source)).toEqual(
      right([
        [
          none,
          [
            Expr.PropertyMatch({
              name: 'name',
              exprs: [Expr.AnyString(null), Expr.Truthy(null)],
            }),
            Expr.PropertyMatch({ name: 'age', exprs: [Expr.AnyNumber(null)] }),
          ],
          none,
        ],
        '',
      ]),
    )
  })
})