config_parser.js

(function(requirejs, require, define) {
    define([], function() {
        return configParser;

        function configParser(state, config) {
            state.config = {
                'draggables': [],
                'baseImage': '',
                'targets': [],
                'onePerTarget': null, // Specified by user. No default.
                'targetOutline': true,
                'labelBgColor': '#d6d6d6',
                'individualTargets': null, // Depends on 'targets'.
                'foundErrors': false // Whether or not we find errors while processing the config.
            };

            getDraggables(state, config);
            getBaseImage(state, config);
            getTargets(state, config);
            getOnePerTarget(state, config);
            getTargetOutline(state, config);
            getLabelBgColor(state, config);

            setIndividualTargets(state);

            if (state.config.foundErrors !== false) {
                return false;
            }

            return true;
        }

        function getDraggables(state, config) {
            if (config.hasOwnProperty('draggables') === false) {
                console.log('ERROR: "config" does not have a property "draggables".');
                state.config.foundErrors = true;
            } else if ($.isArray(config.draggables) === true) {
                config.draggables.every(function(draggable) {
                    if (processDraggable(state, draggable) !== true) {
                        state.config.foundErrors = true;

                    // Exit immediately from .every() call.
                        return false;
                    }

                // Continue to next .every() call.
                    return true;
                });
            } else {
                console.log('ERROR: The type of config.draggables is no supported.');
                state.config.foundErrors = true;
            }
        }

        function getBaseImage(state, config) {
            if (config.hasOwnProperty('base_image') === false) {
                console.log('ERROR: "config" does not have a property "base_image".');
                state.config.foundErrors = true;
            } else if (typeof config.base_image === 'string') {
                state.config.baseImage = config.base_image;
            } else {
                console.log('ERROR: Property config.base_image is not of type "string".');
                state.config.foundErrors = true;
            }
        }

        function getTargets(state, config) {
            if (config.hasOwnProperty('targets') === false) {
            // It is possible that no "targets" were specified. This is not an error.
            // In this case the default value of "[]" (empty array) will be used.
            // Draggables can be positioned anywhere on the image, and the server will
            // get an answer in the form of (x, y) coordinates for each draggable.
            } else if ($.isArray(config.targets) === true) {
                config.targets.every(function(target) {
                    if (processTarget(state, target) !== true) {
                        state.config.foundErrors = true;

                    // Exit immediately from .every() call.
                        return false;
                    }

                // Continue to next .every() call.
                    return true;
                });
            } else {
                console.log('ERROR: Property config.targets is not of a supported type.');
                state.config.foundErrors = true;
            }
        }

        function getOnePerTarget(state, config) {
            if (config.hasOwnProperty('one_per_target') === false) {
                console.log('ERROR: "config" does not have a property "one_per_target".');
                state.config.foundErrors = true;
            } else if (typeof config.one_per_target === 'string') {
                if (config.one_per_target.toLowerCase() === 'true') {
                    state.config.onePerTarget = true;
                } else if (config.one_per_target.toLowerCase() === 'false') {
                    state.config.onePerTarget = false;
                } else {
                    console.log('ERROR: Property config.one_per_target can either be "true", or "false".');
                    state.config.foundErrors = true;
                }
            } else {
                console.log('ERROR: Property config.one_per_target is not of a supported type.');
                state.config.foundErrors = true;
            }
        }

        function getTargetOutline(state, config) {
        // It is possible that no "target_outline" was specified. This is not an error.
        // In this case the default value of 'true' (boolean) will be used.

            if (config.hasOwnProperty('target_outline') === true) {
                if (typeof config.target_outline === 'string') {
                    if (config.target_outline.toLowerCase() === 'true') {
                        state.config.targetOutline = true;
                    } else if (config.target_outline.toLowerCase() === 'false') {
                        state.config.targetOutline = false;
                    } else {
                        console.log('ERROR: Property config.target_outline can either be "true", or "false".');
                        state.config.foundErrors = true;
                    }
                } else {
                    console.log('ERROR: Property config.target_outline is not of a supported type.');
                    state.config.foundErrors = true;
                }
            }
        }

        function getLabelBgColor(state, config) {
        // It is possible that no "label_bg_color" was specified. This is not an error.
        // In this case the default value of '#d6d6d6' (string) will be used.

            if (config.hasOwnProperty('label_bg_color') === true) {
                if (typeof config.label_bg_color === 'string') {
                    state.config.labelBgColor = config.label_bg_color;
                } else {
                    console.log('ERROR: Property config.label_bg_color is not of a supported type.');
                }
            }
        }

        function setIndividualTargets(state) {
            if (state.config.targets.length === 0) {
                state.config.individualTargets = false;
            } else {
                state.config.individualTargets = true;
            }
        }

        function processDraggable(state, obj) {
            if (
            (attrIsString(obj, 'id') === false) ||
            (attrIsString(obj, 'icon') === false) ||
            (attrIsString(obj, 'label') === false) ||

            (attrIsBoolean(obj, 'can_reuse', false) === false) ||

            (obj.hasOwnProperty('target_fields') === false)
        ) {
                return false;
            }

        // Check that all targets in the 'target_fields' property are proper target objects.
        // We will be testing the return value from .every() call (it can be 'true' or 'false').
            if (obj.target_fields.every(
            function(targetObj) {
                return processTarget(state, targetObj, false);
            }
        ) === false) {
                return false;
            }

            state.config.draggables.push(obj);

            return true;
        }

    // We need 'pushToState' parameter in order to simply test an object for the fact that it is a
    // proper target (without pushing it to the 'state' object). When
    //
    //     pushToState === false
    //
    // the object being tested is not going to be pushed to 'state'. The function will onyl return
    // 'true' or 'false.
        function processTarget(state, obj, pushToState) {
            if (
            (attrIsString(obj, 'id') === false) ||

            (attrIsInteger(obj, 'w') === false) ||
            (attrIsInteger(obj, 'h') === false) ||

            (attrIsInteger(obj, 'x') === false) ||
            (attrIsInteger(obj, 'y') === false)
        ) {
                return false;
            }

            if (pushToState !== false) {
                state.config.targets.push(obj);
            }

            return true;
        }

        function attrIsString(obj, attr) {
            if (obj.hasOwnProperty(attr) === false) {
                console.log('ERROR: Attribute "obj.' + attr + '" is not present.');

                return false;
            } else if (typeof obj[attr] !== 'string') {
                console.log('ERROR: Attribute "obj.' + attr + '" is not a string.');

                return false;
            }

            return true;
        }

        function attrIsInteger(obj, attr) {
            var tempInt;

            if (obj.hasOwnProperty(attr) === false) {
                console.log('ERROR: Attribute "obj.' + attr + '" is not present.');

                return false;
            }

            tempInt = parseInt(obj[attr], 10);

            if (isFinite(tempInt) === false) {
                console.log('ERROR: Attribute "obj.' + attr + '" is not an integer.');

                return false;
            }

            obj[attr] = tempInt;

            return true;
        }

        function attrIsBoolean(obj, attr, defaultVal) {
            if (obj.hasOwnProperty(attr) === false) {
                if (defaultVal === undefined) {
                    console.log('ERROR: Attribute "obj.' + attr + '" is not present.');

                    return false;
                } else {
                    obj[attr] = defaultVal;

                    return true;
                }
            }

            if (obj[attr] === '') {
                obj[attr] = defaultVal;
            } else if ((obj[attr] === 'false') || (obj[attr] === false)) {
                obj[attr] = false;
            } else if ((obj[attr] === 'true') || (obj[attr] === true)) {
                obj[attr] = true;
            } else {
                console.log('ERROR: Attribute "obj.' + attr + '" is not a boolean.');

                return false;
            }

            return true;
        }
    }); // End-of: define([], function () {
}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define) {