zippa/lib/test/testVisit.js

A Generic Zipper Library

'use strict';

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _chai = require('chai');

var _chai2 = _interopRequireDefault(_chai);

var _sinonChai = require('sinon-chai');

var _sinonChai2 = _interopRequireDefault(_sinonChai);

var _index = require('../index');

var _tree_zipper = require('./tree_zipper');

var _utils = require('./utils');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_chai2.default.use(_sinonChai2.default);
var expect = _chai2.default.expect;


var log = function log(node) {
    console.log('LOG NODE:', node.data);
    return node;
};

function recordVisitStats(visitorFn) {
    var initialState = {
        itemCount: 0,
        replacedCount: 0,
        replaced: [],
        stopped: false,
        cut: false,
        cutCount: 0,
        stoppedAt: null,
        cutAt: []
    };
    return function (_item, _state) {
        var res = visitorFn(_item, _state);

        var _ref = res || {};

        var item = _ref.item;
        var state = _ref.state;
        var stop = _ref.stop;
        var cut = _ref.cut;

        var __state = state || _state || {};

        if (!__state.hasOwnProperty('stats')) {
            __state.stats = Object.assign({}, initialState);
        }

        var stats = __state.stats;

        stats.itemCount++;

        if (item) {
            stats.replacedCount++;
            stats.replaced.push(item);
        }

        var __item = res.hasOwnProperty('item') ? item : _item;

        if (stop) {
            stats.stopped = true;
            stats.stoppedAt = __item;
        }

        if (cut) {
            stats.cut = true;
            stats.cutCount++;
            stats.cutAt.push(__item);
        }

        var returnObject = {};
        if ((res || {}).hasOwnProperty('item')) returnObject.item = item;
        return _extends({}, returnObject, {
            state: __state,
            stop: stop,
            cut: cut
        });
    };
}

describe('visit', function () {
    function getTree() {
        return new _tree_zipper.Node(1, [new _tree_zipper.Node(2, [new _tree_zipper.Node(4), new _tree_zipper.Node(5)]), new _tree_zipper.Node(3)]);
    }

    it('correct number of pre and post visit events', function () {
        var z = _tree_zipper.TreeZipper.from(getTree());

        var preEvents = 0;
        var postEvents = 0;

        (0, _index.visit)([(0, _index.onPre)(function () {
            preEvents++;
        }), (0, _index.onPost)(function () {
            postEvents++;
        })], null, z);

        expect(preEvents).to.equal(5);
        expect(postEvents).to.equal(5);
    });

    it('stop', function () {
        var z = _tree_zipper.TreeZipper.from(getTree());

        function visitor(item, _) {
            if (item.data === 4) {
                return { stop: true };
            }
            return {};
        }

        var _visit = (0, _index.visit)([(0, _index.onPre)(recordVisitStats(visitor))], {}, z);

        var state = _visit.state;


        var stats = state.stats;

        expect(stats.stopped).to.be.true;
        expect(stats.itemCount).to.equal(3);
    });

    it('cut', function () {
        var z = _tree_zipper.TreeZipper.from(getTree());

        function visitor(item, _) {
            if (item.data === 2) {
                return { cut: true };
            }
            return {};
        }

        var _visit2 = (0, _index.visit)([(0, _index.onPre)(recordVisitStats(visitor))], {}, z);

        var state = _visit2.state;


        var stats = state.stats;

        expect(stats.cut).to.be.true;
        expect(stats.cutAt).to.have.lengthOf(1);
        expect(stats.cutAt[0]).to.equal(z.value().children[0]);
        expect(stats.itemCount).to.equal(3);
    });

    it('replace nodes', function () {
        var z = _tree_zipper.TreeZipper.from(getTree());

        function visitor(item, _) {
            if (item.data === 2 || item.data === 4) {
                return {
                    item: new _tree_zipper.Node(item.data + 1, item.children)
                };
            }
            return {};
        }

        var _visit3 = (0, _index.visit)([(0, _index.onPost)(recordVisitStats(visitor))], {}, z);

        var state = _visit3.state;
        var item = _visit3.item;


        var stats = state.stats;

        expect(stats.replacedCount).to.equal(2);
        expect(stats.itemCount).to.equal(5);
        expect(stats.replaced[0].data).to.equal(5);
        expect(stats.replaced[1].data).to.equal(3);

        expect(item.children[0]).to.equal(stats.replaced[1]);
        expect(item.children[0].children[0]).to.equal(stats.replaced[0]);
    });
});