@masala/parser/src/test/parsec/f-layer-test.js

Masala Parser

import Streams from '../../lib/stream/index'
import { F, C } from '../../lib/parsec/index'

export default {
    setUp: function (done) {
        done()
    },

    'expect F.layer(parser) to work as parser with backtrak on success':
        function (test) {
            const parser = C.char('a').thenEos()
            const successInput = 'a'
            const failInput = 'b'

            const layer = F.layer(parser)

            let response = layer.parse(Streams.ofString(successInput))

            test.ok(response.isAccepted())
            test.equal(response.offset, 0)

            // Fail test
            response = layer.parse(Streams.ofString(failInput))

            test.ok(!response.isAccepted())
            test.equal(response.offset, 0)
            test.done()
        },

    'expect F.layer(parser).and(other) to succeed': function (test) {
        try {
            const first = C.char('a')
                .then(C.char('a'))
                .thenEos()
                .array()
                .map((r) => r.length)

            const second = C.string('aa').thenEos()

            const successInput = 'aa'

            const layer = F.layer(first).and(second).and(second).array()

            let response = layer.parse(Streams.ofString(successInput))

            test.ok(response.isAccepted())
            test.deepEqual(response.value, [2, 'aa', 'aa'])
            test.equal(response.offset, 2)
        } catch (e) {
            console.log(e)
        }
        test.done()
    },

    'expect F.layer(first).and(second).and(third) to be associative': function (
        test,
    ) {
        const first = C.char('a')
            .then(C.char('a'))
            .thenEos()
            .array()
            .map((r) => r.length)
        const second = C.char('a')
            .then(C.char('a'))
            .thenEos()
            .array()
            .map((r) => r.join('-'))
        const third = C.string('aa').thenEos()

        const input = 'aa'

        const layer = F.layer(first).and(second).and(third).array()

        let response = layer.parse(Streams.ofString(input))

        test.ok(response.isAccepted())
        test.deepEqual(response.value, [2, 'a-a', 'aa'])
        test.equal(response.offset, 2)
        test.done()
    },
    'expect F.layer(parser).and(other) to fail with second': function (test) {
        const first = C.char('a')
            .then(C.char('a'))
            .array()
            .thenEos()
            .map((r) => r.length)
        const second = C.string('aaFAIL').thenEos()

        const successInput = 'aa'

        const layer = F.layer(first).and(second).array()

        let response = layer.parse(Streams.ofString(successInput))

        test.ok(!response.isAccepted())
        test.equal(response.offset, 0)
        test.equal(response.value, undefined)
        test.done()
    },
    'expect F.layer(parser).and(other) to fail with first': function (test) {
        const first = C.char('a')
            .then(C.char('a'))
            .thenEos()
            .map((r) => r.length)

        const second = C.string('aaSUCCESS').thenEos()

        const successInput = 'aaSUCCESS' // first fail by not meeting Eos
        const layer = F.layer(first).and(second)

        let response = layer.parse(Streams.ofString(successInput))

        test.ok(!response.isAccepted())
        test.equal(response.offset, 2) // stop at first because could not find the Eos
        test.equal(response.value, undefined)
        test.done()
    },

    'expect F.layer(parser).and(other) to not move on the second after first fails':
        function (test) {
            const first = C.char('a')
                .then(C.char('a'))
                .thenEos()
                .map((r) => r.length)

            let found = false
            const second = C.string('aaSUCCESS')
                .thenEos()
                .map((x) => {
                    found = true
                    return x
                })

            const successInput = 'aaSUCCESS' // first fail by not meeting Eos

            const layer = F.layer(first).and(second)
            let response = layer.parse(Streams.ofString(successInput))

            test.ok(!response.isAccepted())
            test.equal(response.offset, 2)
            test.equal(false, found) // second was not even tried
            test.done()
        },
}