verificator/lib/actions/rules.js

Client and server-side validation JavaScript library

'use strict';

exports.__esModule = true;
exports.setRules = undefined;

var _get = require('../utils/get');

var _get2 = _interopRequireDefault(_get);

var _isPlainObject = require('../utils/isPlainObject');

var _isPlainObject2 = _interopRequireDefault(_isPlainObject);

var _types = require('../constants/types');

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

var parseParameters = function parseParameters(rule, parameter) {
    if (Array.isArray(parameter)) {
        return parameter;
    }
    if (rule.toLowerCase() === 'regex') {
        return [parameter];
    }
    return parameter.split(',');
};
var parseRule = function parseRule(rule) {
    if (Array.isArray(rule)) {
        return {
            name: rule[0].trim(),
            parameters: rule.slice(1)
        };
    }
    var name = rule.indexOf(':') > -1 ? rule.substr(0, rule.indexOf(':')) : rule;
    var parameter = rule.indexOf(':') > -1 ? rule.substr(rule.indexOf(':') + 1) : [];
    var parameters = parseParameters(name, parameter);
    return {
        name: name.trim(),
        parameters: parameters
    };
};
var parseRules = function parseRules(rules) {
    if (typeof rules === 'string') {
        rules = rules.split('|');
    }
    return rules.filter(function (rule) {
        return (Array.isArray(rule) || typeof rule === 'string') && rule.length;
    }).map(parseRule);
};
var setRules = exports.setRules = function setRules(data, initialRules) {
    var _rules = {};
    var _attributes = {};
    function explodeRules(attribute, rule) {
        if (attribute.indexOf('*') > -1) {
            var path = attribute.substr(0, attribute.indexOf('*') - 1);
            var value = (0, _get2['default'])(data, path);
            if (value) {
                if (Array.isArray(value)) {
                    value.forEach(function (v, i) {
                        explodeRules(attribute.replace('*', String(i)), rule);
                    });
                } else if ((0, _isPlainObject2['default'])(value)) {
                    Object.keys(value).forEach(function (key) {
                        explodeRules(attribute.replace('*', key), rule);
                    });
                }
            }
        } else {
            var name = rule[0],
                rules = rule[1];

            _rules[attribute] = parseRules(rules);
            if (name.indexOf('*') > -1) {
                _attributes[name] = _attributes[name] || [];
                _attributes[name].push(attribute);
            }
        }
    }
    Object.keys(initialRules).forEach(function (attribute) {
        explodeRules(attribute, [attribute, initialRules[attribute]]);
    });
    return {
        type: _types.SET_RULES,
        payload: {
            initialRules: initialRules,
            rules: _rules,
            implicitAttributes: _attributes
        }
    };
};