Changeset 7361

Timestamp:

02/19/07 18:31:49 (23 months ago)

Author:

peller

Message:

Use regular expressions to parse in dojo.number, expose method to get the regular expression. References #2475

Location:

trunk/src

Files:

• number.js (modified) (5 diffs)
• regexp.js (modified) (5 diffs)

trunk/src/number.js

@@ -7 +7 @@
 dojo.require("dojo.string.common");
 dojo.require("dojo.string.extras");
-dojo.require("dojo.regexp"); // should we eliminate this dependency or try to make use of regexp number routines?
+dojo.require("dojo.regexp");
 
 dojo.number.format = function(/*Number*/value, /*Object?*/options){
@@ -35 +35 @@
 };
 
-dojo.number._numberPatternRE = /(?:[#0]*,?)*[#0]+(?:\.0*#*)?/; // not precise, but good enough
+//dojo.number._numberPatternRE = /(?:[#0]*,?)*[#0](?:\.0*#*)?/; // not precise, but good enough
+dojo.number._numberPatternRE = /[#0,]*[#0](?:\.0*#*)?/; // not precise, but good enough
 
 dojo.number.applyPattern = function(/*Number*/value, /*String*/pattern, /*Object?*/options){
@@ -161 +162 @@
 };
 
+dojo.number.regexp = function(/*Object?*/options){
+//
+// summary:
+//              Builds the regular needed to parse a number
+//
+// description:
+//              returns regular expression with positive and negative match, group and decimal separators
+//
+// options: object {pattern: String, type: String locale: String, strict: Boolean, places: mixed}
+//              pattern- override pattern with this string
+//              type- choose a format type based on the locale from the following: decimal, scientific, percent, currency. decimal by default.
+//              locale- override the locale used to determine formatting rules
+//              strict- strict parsing, false by default
+//              places- number of decimal places to accept: Infinity, a positive number, or a range "n,m"
+        return dojo.number._parseInfo(options).regexp; // String
+}
+
+dojo.number._parseInfo = function(/*Object?*/options){
+        options = options || {};
+        var locale = dojo.hostenv.normalizeLocale(options.locale);
+        var bundle = dojo.i18n.getLocalization("dojo.i18n.cldr", "number", locale);
+        var pattern = options.pattern || bundle[(options.type || "decimal") + "Format"];
+//TODO: memoize?
+        var group = bundle.group;
+//      if(!options.strict){ group = [group,""]; }
+        var decimal = bundle.decimal;
+
+        //TODO: handle quoted escapes
+        var patternList = pattern.split(';');
+        if (patternList.length == 1){
+                patternList.push("-" + patternList[0]); // substitute negative sign?
+        }
+
+        var re = dojo.regexp.buildGroupRE(patternList, function(pattern){
+                pattern = "(?:"+dojo.string.escape('regexp', pattern, '.')+")";
+                return pattern.replace(dojo.number._numberPatternRE, function(format){
+                        var flags = {
+                                signed: false,
+                                separator: options.strict ? group : [group,""],
+                                decimal: decimal,
+                                exponent: false};
+                        var parts = format.split('.');
+                        if(parts.length == 1){parts.fractional = false;}
+                        else{
+                                var places = options.places;
+                                if(typeof places == "undefined"){ places = parts[1].lastIndexOf('0')+1; }
+                                if(places){parts.fractional = true;} // required fraction
+                                flags.places = places;
+                                if(places < parts[1].length){ flags.places += "," + parts[1].length; }
+                        }
+                        var groups = parts[0].split(',');
+                        if(groups.length>1){
+                                flags.groupSize = groups.pop().length;
+                                if(groups.length>1){
+                                        flags.groupSize2 = groups.pop().length;
+                                }
+                        }
+                        return "("+dojo.regexp.realNumber(flags)+")";
+                });
+        }, true);
+
+        if(!options.strict){
+                // TODO: handle .### with no leading integer?
+                //TODO: !strict: make currency symbol too
+        }
+
+        return {regexp: re, group: group, decimal: decimal}; // Object
+}
+
 dojo.number.parse = function(/*String*/expression, /*Object?*/options){
 //
@@ -176 +246 @@
 // options: object {pattern: string, locale: string, strict: boolean}
 //              pattern- override pattern with this string
+//              type- choose a format type based on the locale from the following: decimal, scientific, percent, currency. decimal by default.
 //              locale- override the locale used to determine formatting rules
 //              strict- strict parsing, false by default
 
-        options = options || {};
-        var locale = dojo.hostenv.normalizeLocale(options.locale);
-        var bundle = dojo.i18n.getLocalization("dojo.i18n.cldr", "number", locale);
-        var pattern = options.pattern || bundle[(options.type || "decimal") + "Format"];
-        var group = bundle.group;
-        var decimal = bundle.decimal;
-
-        //TODO: handle quoted escapes
-        var patternList = pattern.split(';');
-        if (patternList.length == 1){
-                patternList.push("-" + patternList[0]); // substitute negative sign?
-        }
-
-        if(options.strict && !dojo.number._buildNumberFormatRE(pattern, {/*TODO*/}).test(expression)){
-                return NaN; //NaN
-        }
-
-        var re = dojo.regexp.buildGroupRE(patternList, function(pattern){
-                pattern = dojo.regexp.group(dojo.string.escape('regexp', pattern, '.'), true);
-                return pattern.replace(dojo.number._numberPatternRE, "([\\d\\"+group+"]+(?:\\"+decimal+"\\d+)?)"); // also handle .### with no leading integer?
-        }, true);
+        var info = dojo.number._parseInfo(options);
+        var group = info.group;
+        var decimal = info.decimal;
+        var re = info.regexp;
 
 //TODO: substitute currency symbol, percent/permille/etc.
@@ -220 +274 @@
                 //TODO: handle exponent
         }
-
         return value;
 };
-
-dojo.number._buildNumberFormatRE = function(/*String*/pattern, /*Object*/options){
-//TODO: sign
-//TODO: currency
-//TODO: exp?
-//TODO: number groups
-        dojo.unimplemented("dojo.number._buildNumberFormatRE");
-        var numberPatternRE = dojo.number._numberPatternRE;
-        var numberPattern = pattern.match(numberPatternRE);
-        if(!numberPattern){
-                dojo.raise("unable to find a number expression in pattern: "+pattern);
-        }
-        //TODO: escape special chars in regexp
-        pattern = pattern.replace(numberPatternRE, "\\d...");
-        return new RegExp("^" + pattern + "$"); // RegExp
-//TODO: memoize?
-};

trunk/src/regexp.js

@@ -256 +256 @@
         // build sign RE
         var signRE = dojo.regexp.buildGroupRE(flags.signed,
-                function(q) { return q ? "[-+]" : ""; }
+                function(q) { return q ? "[-+]" : ""; },
+                true
         );
 
@@ -262 +263 @@
         var numberRE = dojo.regexp.buildGroupRE(flags.separator,
                 function(sep){ 
-                        if(sep == ""){ 
-                                return "(0|[1-9]\\d*)";
+                        if(!sep){ 
+                                return "(?:0|[1-9]\\d*)";
                         }
                         var grp = flags.groupSize, grp2 = flags.groupSize2;
-                        if(typeof grp2 != "undefined"){
-                                var grp2RE = "(0|[1-9]\\d{0," + (grp2-1) + "}([" + sep + "]\\d{" + grp2 + "})*[" + sep + "]\\d{" + grp + "})";
-                                return ((grp-grp2) > 0) ? "(" + grp2RE + "|(0|[1-9]\\d{0," + (grp-1) + "}))" : grp2RE;
+                        if(grp2){
+                                var grp2RE = "(?:0|[1-9]\\d{0," + (grp2-1) + "}(?:[" + sep + "]\\d{" + grp2 + "})*[" + sep + "]\\d{" + grp + "})";
+                                return ((grp-grp2) > 0) ? "(?:" + grp2RE + "|(?:0|[1-9]\\d{0," + (grp-1) + "}))" : grp2RE;
                         }
-                        return  "(0|[1-9]\\d{0," + (grp-1) + "}([" + sep + "]\\d{" + grp + "})*)";
-                }
+                        return "(?:0|[1-9]\\d{0," + (grp-1) + "}(?:[" + sep + "]\\d{" + grp + "})*)";
+                },
+                true
         );
 
@@ -282 +284 @@
         //
         // flags:An object
-        //    flags.places  The integer number of decimal places.
+        //    flags.places  The integer number of decimal places or a range given as "n,m"
         //      If not given, the decimal part is optional and the number of places is unlimited.
         //    flags.decimal  A string for the character used as the decimal point.  Default is ".".
@@ -295 +297 @@
         // assign default values to missing paramters
         flags = (typeof flags == "object") ? flags : {};
-        if(typeof flags.places != "number"){ flags.places = Infinity; }
+        if(typeof flags.places == "undefined"){ flags.places = Infinity; }
         if(typeof flags.decimal != "string"){ flags.decimal = "."; }
         if(typeof flags.fractional == "undefined"){ flags.fractional = [true, false]; }
@@ -308 +310 @@
                 function(q){
                         var re = "";
-                        if(q && (flags.places > 0)){
+                        if(q && (flags.places!==0)){
                                 re = "\\" + flags.decimal;
                                 if(flags.places == Infinity){ 
-                                        re = "(" + re + "\\d+)?"; 
-                                }else{ 
-                                        re = re + "\\d{" + flags.places + "}"; 
+                                        re = "(?:" + re + "\\d+)?"; 
+                                }else{
+                                        re += "\\d{" + flags.places + "}"; 
                                 }
                         }
-
                         return re;
-                }
+                },
+                true
         );