siesta-lite/lib/Siesta/Launcher/Role/CanProcessArguments.js

Stress-free JavaScript unit testing and functional testing tool, works in NodeJS and browsers

/*

Siesta 5.6.1
Copyright(c) 2009-2022 Bryntum AB
https://bryntum.com/contact
https://bryntum.com/products/siesta/license

*/
Role('Siesta.Launcher.Role.CanProcessArguments', {

    methods : {

        processArguments : function (args) {
            var options             = {}
            var argv                = []
            var positionalGroups    = {}

            var currentOption

            var addOption   = function (name, value, optionsBag) {
                if (optionsBag.hasOwnProperty(name)) {
                    var prevValue   = optionsBag[ name ]

                    if (!(prevValue instanceof Array)) optionsBag[ name ] = [ prevValue ]

                    optionsBag[ name ].push(value)

                } else
                    optionsBag[ name ] = value

                currentOption = null
            }

            for (var i = 0; i < args.length; i++) {
                var arg     = args[ i ]

                var match   = /^\s*--([\w_\-\.]+)(?=\=(.*)|$)/.exec(arg)

                // we get a switch like, --option or --option=value
                if (match) {
                    var optionName      = match[ 1 ]
                    var optionValue     = match[ 2 ]
                    var groupMatch

                    if (groupMatch = /([\w_-]+)\.([\w_-]+)/.exec(optionName)) {
                        var groupName       = groupMatch[ 1 ]

                        if (!positionalGroups[ groupName ]) positionalGroups[ groupName ] = []

                        positionalGroups[ groupName ].push('--' + groupMatch[ 2 ] + (optionValue != null ? '=' + optionValue : ''))
                    }

                    // dealing with current state first
                    // option w/o values get `new Boolean(true)` as value
                    if (currentOption) addOption(currentOption, new Boolean(true), options)

                    // now processing a new match
                    if (optionValue != undefined)
                        addOption(optionName, optionValue, options)
                    else
                        currentOption = optionName

                } else
                    if (currentOption)
                        addOption(currentOption, arg, options)
                    else
                        argv.push(arg)
            }

            // option w/o values get `new Boolean(true)` as value
            if (currentOption) addOption(currentOption, new Boolean(true), options)

            var groups          = {}
            var regularOptions  = {}

            var match

            for (var name in options) {
                if (match = /([\w_-]+)\.([\w_-]+)/.exec(name)) {
                    var groupName   = match[ 1 ]
                    var optionName  = match[ 2 ]

                    var group       = groups[ groupName ] = groups[ groupName ] || {}

                    addOption(optionName, options[ name ], group)
                } else {
                    regularOptions[ name ] = options[ name ]
                }
            }

            return {
                options             : regularOptions,
                argv                : argv,
                groups              : groups,
                positionalGroups    : positionalGroups
            }
        }
    }
    // eof methods
})