How to use the gemini-configparser.map function in gemini-configparser

'use strict';
var path = require('path'),
    configparser = require('gemini-configparser'),
    GeminiError = require('../errors/gemini-error'),
    option = configparser.option,
    map = configparser.map;

function is(type) {
    return function(value) {
        if (typeof value !== type) {
            throw new GeminiError('a value must be ' + type);
        }
    };
}

exports.assertNonNegative = (value, optName) => {
    is('number')(value);
    if (value < 0) {
        throw new GeminiError(`"${optName}" must be non-negative`);
    }
};

'use strict';

const path = require('path');
const configparser = require('gemini-configparser');

const option = configparser.option;
const map = configparser.map;

const is = exports.is = (type) => {
    return (value) => {
        if (typeof value !== type) {
            throw new Error(`value must be a ${type}`);
        }
    };
};

exports.resolveWithProjectDir = (value) => {
    return value ? path.resolve(process.cwd(), value) : value;
};

const parseBoolean = exports.parseBoolean = (value) => {
    switch (value.toLowerCase()) {
        case '1':

'use strict';

const _ = require('lodash');
const configparser = require('gemini-configparser');
const utils = require('./utils');

const option = configparser.option;
const map = configparser.map;

const assertNonNegativeInteger = utils.assertNonNegativeInteger;
const assertPositiveInteger = utils.assertPositiveInteger;
const assertPositiveIntegerOrInfinity = utils.assertPositiveIntegerOrInfinity;
const assertOptionalObject = utils.assertOptionalObject;
const assertOptionalArray = utils.assertOptionalArray;
const parseBoolean = utils.parseBoolean;
const parsePrimitive = utils.parsePrimitive;
const is = utils.is;

module.exports = (defaultFactory) => {
    return {
        boolean,
        optionalArray,
        optionalObject,
        optionalFunction,

const GeminiError = require('../errors/gemini-error');
const util = require('./util');

const browserOptions = require('./browser-options');
const coreOptions = require('gemini-core').config.options;
const ENV_PREFIX = `${require('../../package').name}_`;

const is = util.is;
const anyObject = util.anyObject;
const resolveWithProjectRoot = util.resolveWithProjectRoot;
const booleanOption = util.booleanOption;
const positiveIntegerOption = util.positiveIntegerOption;
const root = configparser.root;
const section = configparser.section;
const option = configparser.option;
const map = configparser.map;

module.exports = root(
    section(_.extend(browserOptions.getTopLevel(), {
        system: section({
            projectRoot: option({
                validate: is('string'),
                map: _.ary(path.resolve, 1)
            }),

            sourceRoot: option({
                validate: is('string'),
                map: resolveWithProjectRoot,
                defaultValue: (config) => config.system.projectRoot
            }),

            tempDir: option({

'use strict';

const _ = require('lodash');
const configparser = require('gemini-configparser');
const browserOptions = require('./browser-options');
const defaults = require('./defaults');
const optionsBuilder = require('./options-builder');

const options = optionsBuilder(_.propertyOf(defaults));

const section = configparser.section;
const map = configparser.map;

const coreOptions = require('gemini-core').config.options;

const ENV_PREFIX = `${require('../../package').name}_`;

const rootSection = section(_.extend(browserOptions.getTopLevel(), {

    browsers: map(section(browserOptions.getPerBrowser())),

    prepareEnvironment: options.optionalFunction('prepareEnvironment'),

    system: section({
        debug: options.boolean('debug'),

        mochaOpts: options.optionalObject('mochaOpts'),