roc/lib/documentation/build-documentation-object.js

Build modern web applications easily

'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; };

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = buildDocumentationObject;
exports.sortOnProperty = sortOnProperty;

var _lodash = require('lodash');

var _helpers = require('./helpers');

var _onProperty = require('../helpers/on-property');

var _onProperty2 = _interopRequireDefault(_onProperty);

var _automatic = require('../converters/automatic');

var _automatic2 = _interopRequireDefault(_automatic);

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

const defaultValidation = (input, info) => info ? { type: 'Unknown' } : true;

/**
 * Creates a {@link rocDocumentationObject}.
 *
 * @param {Object} initalObject - The object to create a {@link rocDocumentationObject} of.
 * @param {rocMetaSettings} meta - The meta object to use.
 * @param {string[]} [initalFilter=[]] - The groups that should be used, will default to all groups.
 * @param {number}  [initalLevel=0] - The level that the groups should be based on.
 *
 * @returns {rocDocumentationObject} - The completed documentation object.
 */
function buildDocumentationObject(initalObject) {
    let meta = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
    let initalFilter = arguments.length <= 2 || arguments[2] === undefined ? [] : arguments[2];
    let initalLevel = arguments.length <= 3 || arguments[3] === undefined ? 0 : arguments[3];

    const allObjects = function allObjects() {
        let object = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
        let callback = arguments[1];

        return Object.keys(object).map(callback).filter(value => value !== undefined);
    };

    const manageGroup = function manageGroup(object, name) {
        let group = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
        let description = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
        let validation = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4];
        let converters = arguments.length <= 5 || arguments[5] === undefined ? {} : arguments[5];
        let parents = arguments[6];
        let level = arguments[7];
        let parentNames = arguments[8];

        const groupDescription = (0, _lodash.isPlainObject)(group) ? group._description || undefined : group;
        return {
            name,
            parentNames,
            level,
            description: groupDescription,
            objects: recursiveHelper(object, group, description, validation, converters, [], level + 1, parents, parentNames.concat(name), true),
            children: recursiveHelper(object, group, description, validation, converters, [], level + 1, parents, parentNames.concat(name))
        };
    };

    const manageLeaf = function manageLeaf(object, name, description) {
        let validation = arguments.length <= 3 || arguments[3] === undefined ? defaultValidation : arguments[3];
        let converter = arguments[4];
        let parents = arguments[5];

        var _ref = (0, _lodash.isFunction)(validation) ? validation(null, true) : { type: validation.toString(), req: false };

        var _ref$type = _ref.type;
        const type = _ref$type === undefined ? 'Unknown' : _ref$type;
        var _ref$required = _ref.required;
        const required = _ref$required === undefined ? false : _ref$required;


        const cli = (0, _helpers.toCliOption)(parents);
        return {
            name,
            description,
            type,
            required,
            cli,
            path: parents.join('.'),
            defaultValue: object,
            validator: validation,
            converter: converter || (0, _automatic2.default)(object, cli)
        };
    };

    function recursiveHelper(object) {
        let groups = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
        let descriptions = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
        let validations = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
        let converters = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4];
        let filter = arguments.length <= 5 || arguments[5] === undefined ? [] : arguments[5];
        let level = arguments.length <= 6 || arguments[6] === undefined ? 0 : arguments[6];
        let initalParents = arguments.length <= 7 || arguments[7] === undefined ? [] : arguments[7];
        let parentNames = arguments.length <= 8 || arguments[8] === undefined ? [] : arguments[8];
        let leaves = arguments.length <= 9 || arguments[9] === undefined ? false : arguments[9];

        return allObjects(object, key => {
            // Make sure that we either have no filter or that there is a match
            if (filter.length === 0 || filter.indexOf(key) !== -1) {
                const parents = [].concat(initalParents, key);
                const value = object[key];
                if ((0, _lodash.isPlainObject)(value) && Object.keys(value).length > 0 && !leaves) {
                    const group = (0, _lodash.isPlainObject)(groups) ? groups[key] : {};
                    return manageGroup(value, key, group, descriptions[key], validations[key], converters[key], parents, level, parentNames);
                } else if ((!(0, _lodash.isPlainObject)(value) || Object.keys(value).length === 0) && leaves) {
                    return manageLeaf(value, key, descriptions[key], validations[key], converters[key], parents);
                }
            }
        });
    }

    return recursiveHelper(initalObject, meta.groups, meta.descriptions, meta.validations, meta.converters, initalFilter, initalLevel);
}

/**
 * Sort a documentationObject on a specific property.
 *
 * @param {string} property - The property to sort on.
 * @param {rocDocumentationObject} documentationObject - The documentationObject to sort.
 *
 * @returns {rocDocumentationObject} - The sorted documentationObject.
 */
function sortOnProperty(property) {
    let documentationObject = arguments.length <= 1 || arguments[1] === undefined ? [] : arguments[1];

    documentationObject.sort((0, _onProperty2.default)(property));
    return documentationObject.map(group => {
        return _extends({}, group, {
            objects: sortOnProperty(property, group.objects),
            children: sortOnProperty(property, group.children)
        });
    });
}
//# sourceMappingURL=build-documentation-object.js.map