File: number/js/number-parse.js

            /**
             * Parse number submodule.
             *
             * @module datatype-number
             * @submodule datatype-number-parse
             * @for Number
             */
            
            var safe = Y.Escape.regex,
                SPACES = '\\s*';
            
            Y.mix(Y.namespace("Number"), {
                /**
                 * Returns a parsing function for the given configuration.
                 * It uses `Y.cached` so it expects the format spec separated into
                 * individual values.
                 * The method further uses closure to put together and save the
                 * regular expresssion just once in the outer function.
                 *
                 * @method _buildParser
                 * @param [prefix] {String} Prefix string to be stripped out.
                 * @param [suffix] {String} Suffix string to be stripped out.
                 * @param [separator] {String} Thousands separator to be stripped out.
                 * @param [decimal] {String} Decimal separator to be replaced by a dot.
                 * @return {Function} Parsing function.
                 * @private
                 */
                _buildParser: Y.cached(function (prefix, suffix, separator, decimal) {
                    var regexBits = [],
                        regex;
            
                    if (prefix) {
                        regexBits.push('^' + SPACES + safe(prefix) + SPACES);
                    }
                    if (suffix) {
                        regexBits.push(SPACES + safe(suffix) + SPACES + '$');
                    }
                    if (separator) {
                        regexBits.push(safe(separator) + '(?=\\d)');
                    }
            
                    regex = new RegExp('(?:' + regexBits.join('|') + ')', 'g');
            
                    if (decimal === '.') {
                        decimal = null;
                    }
                    return function (val) {
                        val = val.replace(regex, '');
            
                        return decimal ? val.replace(decimal, '.') : val;
                    };
                }),
                /**
                 * Converts data to type Number.
                 * If a `config` argument is used, it will strip the `data` of the prefix,
                 * the suffix and the thousands separator, if any of them are found,
                 * replace the decimal separator by a dot and parse the resulting string.
                 * Extra whitespace around the prefix and suffix will be ignored.
                 *
                 * @method parse
                 * @param data {String | Number | Boolean} Data to convert. The following
                 * values return as null: null, undefined, NaN, "".
                 * @param [config] {Object} Optional configuration values, same as for [Y.Date.format](#method_format).
                 * @param [config.prefix] {String} String to be removed from the start, like a currency designator "$"
                 * @param [config.decimalPlaces] {Number} Ignored, it is accepted only for compatibility with [Y.Date.format](#method_format).
                 * @param [config.decimalSeparator] {String} Decimal separator.
                 * @param [config.thousandsSeparator] {String} Thousands separator.
                 * @param [config.suffix] {String} String to be removed from the end of the number, like " items".
                 * @return {Number} A number, or null.
                 */
            
                parse: function(data, config) {
                    var parser;
            
                    if (config && typeof data === 'string') {
                        parser = this._buildParser(config.prefix, config.suffix, config.thousandsSeparator, config.decimalSeparator);
            
                        data = parser(data);
                    }
            
                    if (typeof data === 'string' && Y.Lang.trim(data) !== '') {
                        data = +data;
                    }
            
                    // catch NaN and ±Infinity
                    if (typeof data !== 'number' || !isFinite(data)) {
                        data = null;
                    }
            
                    // on the same line to get stripped for raw/min.js by build system
                    if (data === null) { Y.log("Could not parse data to type Number", "warn", "number"); }
            
                    return data;
                }
            });
            
            // Add Parsers shortcut
            Y.namespace("Parsers").number = Y.Number.parse;
            Y.namespace("DataType");
            Y.DataType.Number = Y.Number;