@masala/parser/src/test/parsec/parser_stream_test.js

Masala Parser

import stream from '../../lib/stream/index';
import C from '../../lib/parsec/chars-bundle';
import N from '../../lib/parsec/numbers-bundle';
import Streams from "../../lib/stream";
import unit from "../../lib/data/unit";


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


    'endOfStream for empty stream': function (test) {

        var p = C.char(' ').optrep().thenRight(N.number());
        test.ok(
            stream.ofParser(p, stream.ofString('')).endOfStream(0),
            'should be endOfStream.'
        );
        test.done();
    },


    'endOfStream for non empty stream': function (test) {

        var p = C.char(' ').optrep().thenRight(N.number());
        test.ok(
            stream.ofParser(p, stream.ofString('1')).endOfStream(1),
            'should be endOfStream.'
        );
        test.done();
    },


    'no endOfStream for non empty stream': function (test) {

        var p = C.char(' ').optrep().thenRight(N.number());
        test.equal(
            stream.ofParser(p, stream.ofString('1')).endOfStream(0),
            false,
            'should be endOfStream.'
        );
        test.done();
    },

    'get from stream': function (test) {

        var p = C.char(' ').optrep().thenRight(N.number());
        test.equal(
            stream.ofParser(p, stream.ofString('1')).get(0).isSuccess(),
            true,
            'should be a success.'
        );
        test.done();
    },

    'do not get from empty stream': function (test) {

        var p = C.char(' ').optrep().thenRight(N.number());
        test.equal(
            stream.ofParser(p, stream.ofString('1')).get(1).isSuccess(),
            false,
            'should be a failure.'
        );
        test.done();
    },

    'get from stream number 123': function (test) {

        var p = C.char(' ').optrep().thenRight(N.number()).single();
        test.equal(
            stream.ofParser(p, stream.ofString('123')).get(0).success(),
            123,
            'should be a 123.'
        );
        test.done();
    },


    'Offset are found in series of numbers': function (test) {

        const p = N.number()
            .then(C.char(' ').optrep().drop()).single();

        const parserStream = stream.ofParser(p, stream.ofString('123   14137'));
        // index: ^0    ^6


        const first = parserStream.get(0).success(); //>> 123
        test.equal(first, 123);

        const second = parserStream.get(1).success(); //>> 114
        test.equal(second, 14137);
        test.deepEqual(parserStream.offsets, [0, 6, 11]);

        // Offset after reading start (1) is related to index after 123 (3)
        // Offset after reading at 6 (7) is related to index after '123   14137'(11)


        test.done();
    },

    'failing series of numbers': function (test) {

        const p = N.number()
            .then(C.char(' ').optrep().drop()).single();
        const parserStream = stream.ofParser(p, stream.ofString('123   a'));
        //                                                index: ^0    ^6


        const first = parserStream.get(0).success(); //>> 123
        test.equal(first, 123);
        test.deepEqual(parserStream.offsets, [0, 6]);

        const second = parserStream.get(1); // try 'a'
        test.ok(second.isFailure());

        test.deepEqual(parserStream.offsets, [0, 6]);

        test.done();
    },

    'having correct location when success': function (test) {

        const p = N.number()
            .then(C.char(' ').optrep().drop()).single();

        const parserStream = stream.ofParser(p, stream.ofString('123   14137'));
        //                                                index: ^0    ^6


        const first = parserStream.get(0).success(); //>> 123
        test.equal(first, 123);
        test.equal(0, parserStream.location(0));

        const second = parserStream.get(1).success(); //>> 114
        test.equal(second, 14137);
        test.equal(6, parserStream.location(1));

        test.done();
    },

    'searching illegal location will fail': function (test) {

        const p = N.number()
            .then(C.char(' ').optrep().drop()).single();

        const parserStream = stream.ofParser(p, stream.ofString('123   14137'));
        //                                                index: ^0    ^6


        const first = parserStream.get(0).success(); //>> 123
        test.equal(first, 123);
        let foundError = false;

        try{
            test.equal(0, parserStream.location(4));
        }catch(e){
            foundError = true;
        }

        test.ok(foundError);

        test.done();
    },


    'having correct location when fail': function (test) {

        const p = N.number();

        const parserStream = stream.ofParser(p, stream.ofString('1234   14137'));
        //                                                index: ^0  ^4


        const first = parserStream.get(0).success(); //>> 123
        test.equal(first, 1234);
        test.equal(0, parserStream.location(0));

        parserStream.get(1); //>> fail
        test.equal(4, parserStream.location(1));

        test.done();
    },

    'unsafe_get can see next element': function (test) {
        const lower = N.number().then(spaces().opt().drop()).single();


        const lowerStream = Streams.ofString('10 12 44');
        const parserStream = Streams.ofParser(lower, lowerStream);

        parserStream.unsafeGet(0);

        let value = parserStream.unsafeGet(1);

        test.equal(12, value);


        test.done();
    },

    'unsafe_get cannot see beyond next element': function (test) {
        const lower = N.number().then(spaces().opt().drop());


        const lowerStream = Streams.ofString('10 12 44');
        const parserStream = Streams.ofParser(lower, lowerStream);

        let found = false;

        try {
            parserStream.unsafeGet(1);
        } catch (e) {
            found = true;
        }
        test.ok(found);

        test.done();
    }


};

function spaces() {
    return C.charIn(' \r\n\f\t').optrep().map(() => unit);
}