assert-match/dst/matchers/strict.js

assert + matchers <3

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _create = require('babel-runtime/core-js/object/create');

var _create2 = _interopRequireDefault(_create);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

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

var _lodash = require('lodash.merge');

var _lodash2 = _interopRequireDefault(_lodash);

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

var StrictMatcher = function () {
    function StrictMatcher(expected) {
        (0, _classCallCheck3.default)(this, StrictMatcher);

        this.expected = expected;
    }

    (0, _createClass3.default)(StrictMatcher, [{
        key: 'match',
        value: function match(actual, comparator) {
            return this.check(actual, comparator);
        }
    }, {
        key: 'check',
        value: function check(actual, comparator) {

            var matcherlessActual = this._getActual(actual, this.expected);
            var matcherlessExpected = this._getExpected(actual, this.expected);

            var isMatch = true;

            if (matcherlessActual !== undefined || matcherlessExpected !== undefined) {
                isMatch = comparator(matcherlessActual, matcherlessExpected);
            }

            var appliedMatchers = this._applyMatchers(actual, this.expected, comparator);

            isMatch = isMatch && appliedMatchers.match;

            matcherlessActual = merge(matcherlessActual, appliedMatchers.actual);
            matcherlessExpected = merge(matcherlessExpected, appliedMatchers.expected);

            return {
                match: isMatch,
                actual: matcherlessActual,
                expected: matcherlessExpected
            };
        }
    }, {
        key: '_getActual',
        value: function _getActual(actual, expected) {
            return pickMatcherless(actual, expected);
        }
    }, {
        key: '_getExpected',
        value: function _getExpected(actual, expected) {
            return omitMatchers(expected);
        }
    }, {
        key: '_applyMatchers',
        value: function _applyMatchers(actual, expected, comparator) {
            return applyMatchers(actual, expected, comparator);
        }
    }]);
    return StrictMatcher;
}();

exports.default = StrictMatcher;


function pickMatcherless(actual, expected, iterator) {

    if (!iterator) {
        iterator = (0, _utils.iterateKeys)();
    }

    if ((0, _utils.isMatcher)(expected)) {
        return undefined;
    }

    if (!(0, _utils.isObject)(actual) || (0, _utils.isStandardObject)(actual)) {
        return actual;
    }

    var result = Array.isArray(actual) ? [] : (0, _create2.default)((0, _getPrototypeOf2.default)(actual));

    iterator(actual, function (key) {

        if ((0, _utils.hasOwn)(actual, key)) {

            var expectedValue = (0, _utils.hasOwn)(expected, key) ? expected[key] : undefined;

            // undefined in place of a matcher is ok only for top level
            if (!(0, _utils.isMatcher)(expectedValue)) {
                result[key] = pickMatcherless(actual[key], expectedValue, iterator);
            }
        }
    });

    return result;
}

function omitMatchers(expected, iterator) {

    if (!iterator) {
        iterator = (0, _utils.iterateKeys)();
    }

    if ((0, _utils.isMatcher)(expected)) {
        return undefined;
    }

    if (!(0, _utils.isObject)(expected) || (0, _utils.isStandardObject)(expected)) {
        return expected;
    }

    var result = Array.isArray(expected) ? [] : (0, _create2.default)((0, _getPrototypeOf2.default)(expected));

    iterator(expected, function (key) {

        // undefined in place of a matcher is ok only for top level
        if ((0, _utils.hasOwn)(expected, key) && !(0, _utils.isMatcher)(expected[key])) {
            result[key] = omitMatchers(expected[key], iterator);
        }
    });

    return result;
}

function applyMatchers(actual, expected, comparator, iterator) {

    if (!iterator) {
        iterator = (0, _utils.iterateKeys)();
    }

    if ((0, _utils.isMatcher)(expected)) {
        return expected.match(actual, comparator);
    }

    if (!(0, _utils.isObject)(expected) || (0, _utils.isStandardObject)(expected)) {
        return {
            match: true,
            actual: undefined,
            expected: undefined
        };
    }

    var result = {
        match: true,
        actual: undefined,
        expected: undefined
    };

    iterator(expected, function (key) {

        if ((0, _utils.hasOwn)(expected, key)) {

            var actualValue = (0, _utils.hasOwn)(actual, key) ? actual[key] : undefined;

            var v = applyMatchers(actualValue, expected[key], comparator, iterator);

            result.match = result.match && v.match;

            if (v.actual !== undefined) {
                if (result.actual === undefined) {
                    result.actual = Array.isArray(actual) ? [] : (0, _create2.default)(actual && (0, _getPrototypeOf2.default)(actual));
                }

                result.actual[key] = v.actual;
            }

            if (v.expected !== undefined) {
                if (result.expected === undefined) {
                    result.expected = Array.isArray(expected) ? [] : (0, _create2.default)((0, _getPrototypeOf2.default)(expected));
                }

                result.expected[key] = v.expected;
            }
        }
    });

    return result;
}

function merge(a, b) {

    // it is supposed that if both parts are not == to undef than they should be
    // objects

    if (a == undefined) {
        return b;
    }

    if (b == undefined) {
        return a;
    }

    var base = Array.isArray(a) ? [] : {};

    return (0, _lodash2.default)(base, a, b);
}
module.exports = exports['default'];