Changeset 5777 for branches/i18ndate

Timestamp:

09/23/06 13:05:25 (2 years ago)

Author:

jkuhnert

Message:

Checking in slightly modified incoming patch from Tim Mansfield for date parsing. I've modified a few other things as well
so this shouldn't be a reflection entirely of what Tim was doing but more of a convenience to be able to move my work
in progress items over to a branch without it becoming too much of a PITA to go back to trunk with my work.

Location:

branches/i18ndate

Files:

• src/date/format.js (modified) (7 diffs)
• src/loader.js (modified) (1 diff)
• src/uri/Uri.js (modified) (2 diffs)
• tests/date/test_format.js (modified) (2 diffs)
• tests/widget/test_ComboBox.html (modified) (1 diff)

branches/i18ndate/src/date/format.js

@@ -176 +176 @@
                                         s = Math.round(dateObject.getMilliseconds() * Math.pow(10, l-3));
                                         break;
-                                case 'v': // FIXME: don't know what this is. seems to be same as z?
-                                case 'z':
-                                        // We only have one timezone to offer; the one from the browser
-                                        s = dojo.date.getTimezoneName(dateObject);
-                                        if(s){break;}
-                                        l=4;
-                                        // fallthrough... use GMT if tz not available
                                 case 'Z':
                                         var offset = dateObject.getTimezoneOffset();
@@ -202 +195 @@
                                 case 'g':
                                 case 'A':
+                                case 'v':
+                                case 'z':
                                         dojo.debug(match+" modifier not yet implemented");
                                         s = "?";
@@ -258 +253 @@
 //              strict- strict parsing, off by default
 //
-
-        //TODO: this is still quite rough - it only implements a small portion of the parsing algorithm needed,
-        // and doesn't provide much flexibility in matching.
+        
         var locale = dojo.hostenv.normalizeLocale(options.locale);
         var info = dojo.date._getGregorianBundle(locale);
         var formatLength = options.formatLength || 'full';
-        if (options.selector != 'dateOnly'){ dojo.unimplemented("can only parse dates at this time"); }
-        var pattern = options.datePattern || info["dateFormat-"+formatLength];
+        if (!options.selector) options.selector = 'dateOnly';
+        var datePattern = options.datePattern || info["dateFormat-" + formatLength];
+        var timePattern = options.timePattern || info["timeFormat-" + formatLength];
+
+        var pattern;
+        options.selector = options.selector.toLowerCase();
+        if (options.selector == 'dateonly') {
+                pattern = datePattern;
+        }
+        else if (options.selector == 'timeonly') {
+                pattern = timePattern;
+        } else if (options.selector == 'datetime') {
+                pattern = datePattern + ' ' + timePattern; //TODO: use locale-specific pattern to assemble date + time
+        } else {
+                var msg = "dojo.date.parse: Unknown selector param passed: '" + options.selector + "'.";
+                msg += " Defaulting to date pattern.";
+                dojo.debug(msg);
+                pattern = datePattern;
+        }
+        
+        dojo.debug("Locale: " + locale + ", parsing value '" + value + "' against pattern: " + pattern);
+
+        //DEBUG
+        //for (p in info)
+        //      dojo.debug(p + ': ' + info[p]);
+
         var groups = [];
-
-        var dateREString = _processPattern(pattern, dojo.lang.curry(this, _buildDateTimeRE, groups));
-        //TODO: escape special regexp chars
-        //TODO: make whitespace flexible?
+        var dateREString = _processPattern(pattern, dojo.lang.curry(this, _buildDateTimeRE, groups, info, options));
         var dateRE = new RegExp("^" + dateREString + "$");
 
+        //DEBUG
+        //if (typeof window != 'undefined') window.re = dateRE;
+        
         var match = dateRE.exec(value);
-        if(!match){return null;} // null
-
-        var result = new Date(2004,0);
+        if(!match){
+                return null;
+        }
+
+        var widthList = ['abbr', 'wide', 'narrow'];
+        var result = new Date(1970, 0);
+        var expected = {};
         for(var i=1; i<match.length; i++){
                 var grp=groups[i-1];
@@ -282 +303 @@
                 var v=match[i];
                 switch(grp.charAt(0)){
+                        case 'y':
+                                if(l != 2){
+                                        //interpret year literally, so '5' would be 5 A.D.
+                                        result.setFullYear(v);
+                                        expected.year = v;
+                                } else { 
+                                        if(v<100){
+                                                v = Number(v);
+                                                //choose century to apply, according to a sliding window
+                                                //of 80 years before and 20 years after present year
+                                                var year = '' + new Date().getFullYear();
+                                                var century = year.substring(0, 2) * 100;
+                                                var yearPart = new Number(year.substring(2, 4));
+                                                var cutoff = Math.min(yearPart + 20, 99);
+                                                var num = (v < cutoff) ? century + v : century - 100 + v;
+                                                result.setFullYear(num);
+                                                expected.year = num;
+                                        } else {
+                                                //we expected 2 digits and got more...
+                                                if(options.strict){
+                                                        return null;
+                                                }
+                                                //interpret literally, so '150' would be 150 A.D.
+                                                //also tolerate '1950', if 'yyyy' input passed to 'yy' format
+                                                result.setFullYear(v);
+                                                expected.year = v;
+                                        }
+                                }
+                                break;
+                        case 'M':
+                                if (l>2) {
+                                        if(!options.strict){
+                                                //Tolerate abbreviating period in month part
+                                                v = v.replace(/\./g,'');
+                                                //Case-insensitive
+                                                v = v.toLowerCase();
+                                        }
+                                        var strs = info['months-format-' + widthList[l-3]];
+                                        for (var j=0; j<strs.length; j++) {
+                                                if (!options.strict) {
+                                                        //Case-insensitive
+                                                        strs[j] = strs[j].toLowerCase();
+                                                }
+                                                if (v == strs[j]) {
+                                                        result.setMonth(j);
+                                                        expected.month = j;
+                                                        break;
+                                                }
+                                        }
+                                        if (j==strs.length) {
+                                                dojo.debug("dojo.date.parse: Could not parse month name: '" + v + "'.");
+                                                return null;
+                                        }
+                                } else {
+                                        result.setMonth(v-1);
+                                        expected.month = v-1;
+                                }
+                                break;
+                        case 'E':
+                        case 'e':
+                                if(!options.strict){
+                                        //Case-insensitive
+                                        v = v.toLowerCase();
+                                }
+                                var strs = info['days-format-' + widthList[l-3]];
+                                for (var j=0; j<strs.length; j++) {
+                                        if (!options.strict) {
+                                                //Case-insensitive
+                                                strs[j] = strs[j].toLowerCase();
+                                        }
+                                        if (v == strs[j]) {
+                                                //TODO: not sure what to actually do with this input,
+                                                //in terms of setting something on the Date obj...?
+                                                //without more context, can't affect the actual date
+                                                break;
+                                        }
+                                }
+                                if (j==strs.length) {
+                                        dojo.debug("dojo.date.parse: Could not parse weekday name: '" + v + "'.");
+                                        return null;
+                                }
+                                break;  
                         case 'd':
                                 result.setDate(v);
-                                break;
-                        case 'M':
-                                result.setMonth(v-1);
-                                break;
-                        case 'y':
-                                var century = 0;
-                                if(l == 2){
-                                        if(v<100){
-                                                century = Math.floor(result.getFullYear()/100)*100;
-                                        } else if(options.strict){
-                                                return null; // null
-                                        }
+                                expected.date = v;
+                                break;
+                        case 'a': //am/pm
+                                var am = info['am'];
+                                var pm = info['pm'];
+                                if (!options.strict) {
+                                        v = v.replace(/\./g,'').toLowerCase();
+                                        am = am.replace(/\./g,'').toLowerCase();
+                                        pm = pm.replace(/\./g,'').toLowerCase();
                                 }
-                                result.setFullYear(century+Number(v));
+                                if (options.strict && v != am && v != pm) {
+                                        dojo.debug("dojo.date.parse: Could not parse am/pm part.");
+                                        return null;
+                                }
+                                var hours = result.getHours();
+                                if (v == pm && hours < 12) {
+                                        result.setHours(hours + 12); //e.g., 3pm -> 15
+                                } else if (v == am && hours == 12) {
+                                        result.setHours(0); //12am -> 0
+                                }
+                                break;
+                        case 'h': //hour (1-12)
+                                //in the 12-hour case, adjusting for am/pm requires the 'a' part
+                                //which for now we will assume always comes after the 'h' part
+                                result.setHours(v);
+                                break;
+                        case 'H': //hour (0-23)
+                                result.setHours(v);
+                                break;
+                        case 'k': //hour (0-11)
+                                ++v; //adjust to the 1-12 input that js setHours() expects
+                                //also see 12-hour case comment in the 'h' case above
+                                result.setHours(v);
+                                break;
+                        case 'K': //hour (1-24)
+                                --v; // js setHours() range is 0 to 23
+                                result.setHours(v);
+                                break;
+                        case 'm': //minutes
+                                result.setMinutes(v);
+                                break;
+                        case 's': //seconds
+                                result.setSeconds(s);
                                 break;
                         default:
-                                dojo.unimplemented("incomplete parse algorithm");
+                                dojo.unimplemented("incomplete parse algorithm: " + grp.charAt(0));
                 }
         }
-        return result; // Date
+
+        //validate parse date fields versus input date fields
+        if (expected.year && result.getFullYear() != expected.year) {
+                dojo.debug("Parsed year: '" + result.getFullYear() + "' did not match input year: '" + expected.year + "'.");
+                return null;
+        }
+        if (expected.month && result.getMonth() != expected.month) {
+                dojo.debug("Parsed month: '" + result.getMonth() + "' did not match input month: '" + expected.month + "'.");
+                return null;
+        }
+        if (expected.date && result.getDate() != expected.date) {
+                dojo.debug("Parsed day of month: '" + result.getDate() + "' did not match input day of month: '" + expected.date + "'.");
+                return null;
+        }
+
+        //TODO: need to implement a getWeekday() method in order to test 
+        //validity of input strings containing 'EEE' or 'EEEE'....
+
+        return result; 
 };
 
@@ -316 +466 @@
         var chunks = pattern.split('\'');
         var literal = false;
+//DEBUG
+//for(var i=0; i<chunks.length; i++) { dojo.debug("Chunk #" + i + ": " + chunks[i]); }
+
         for(var i=0; i<chunks.length; i++){
-                if(!chunks[i]){chunks[i]='\'';} //FIXME
-                else{
+                if(!chunks[i]){
+                        chunks[i]=''; //FIXME - was chunks[i]='\''
+                } else{
                         chunks[i]=(literal ? applyLiteral : applyPattern)(chunks[i]);
                         literal = !literal;
                 }
-        }
-
-        return applyAll(chunks.join(""));
+
+//DEBUG
+//dojo.debug("Chunk #" + i + ": " + chunks[i]);
+
+        }
+//DEBUG
+//dojo.debug("Chunks: " + chunks.join(''));
+
+        return applyAll(chunks.join(''));
 }
 
-function _buildDateTimeRE(groups, pattern) {
+function _buildDateTimeRE(groups, info, options, pattern) {
         return pattern.replace(/[a-zA-Z]+/g, function(match){
                 var s;
@@ -334 +494 @@
                 switch(c){
                         case 'y':
-                                s = "\\d" + ((l==2)?"{2,4}":"+");
+                                s = '\\d' + ((l==2) ? '{2,4}' : '+');
                                 break;
                         case 'M':
-                                s = "\\d{1,2}"; //TODO make sure it conforms to month range...
+                                s = (l>2) ? '\\S+' : '\\d{1,2}';
                                 break;
                         case 'd':
-                                s = "\\d{1,2}"; //TODO
-                                break;
-                        case 'h': case 'H': case 'K': case 'k':
-                                s = "\\d{2}"; //TODO
+                                s = '\\d{1,2}';
+                                break;
+                    case 'E':
+                                s = '\\S+';
+                                break;
+                        case 'h': 
+                        case 'H': 
+                        case 'K': 
+                        case 'k':
+                                s = '\\d{2}';
                                 break;
                         case 'm':
                         case 's':
-                                s = "\\d{2}"; //TODO
+                                s = '\\d{2}';
                                 break;
                         case 'S':
-                                s = "\\d+"; //TODO
+                                s = '\\d+';
                                 break;
                         case 'a':
-                                s = info.am + "|" + info.pm;
+                                var am = info.am || 'AM';
+                                var pm = info.pm || 'PM';
+                                if (options.strict) {
+                                        s = am + '|' + pm;
+                                } else {
+                                        s = am;
+                                        s += (am != am.toLowerCase()) ? '|' + am.toLowerCase() : '';
+                                        s += '|';
+                                        s += (pm != pm.toLowerCase()) ? pm + '|' + pm.toLowerCase() : pm;
+                                }
                                 break;
                         default:
-                                dojo.unimplemented("parse of date format, pattern="+pattern);
+                                dojo.unimplemented("parse of date format, pattern=" + pattern);
                 }
                 if(groups){ groups.push(match); }
-                return "("+s+")";
+                return '\\s*(' + s + ')\\s*';
+//DEBUG
+//return '(' + s + ')';
         });
 };
@@ -529 +706 @@
 
                         case "Z": // time zone or name or abbreviation
-                                return dojo.date.getTimezoneName(dateObject);
+                                return dojo.date.getTimezoneName(dateObject); //TODO
                         
                         case "%":

branches/i18ndate/src/loader.js

@@ -593 +593 @@
         if(bundle){
                 if(djConfig.localizationComplete && bundle._built){return;}
-                var jsLoc = dojo.hostenv.normalizeLocale(locale).replace('-','_');
+                var jsLoc = dojo.hostenv.normalizeLocale(locale).replace('_', '-');
                 var translationPackage = bundlePackage+"."+jsLoc;
                 if(dojo.hostenv.findModule(translationPackage)){return;}

branches/i18ndate/src/uri/Uri.js

@@ -33 +33 @@
                         var relobj = new dojo.uri.Uri(arguments[i].toString());
                         var uriobj = new dojo.uri.Uri(uri.toString());
-
+                        
                         if (relobj.path == "" && relobj.scheme == null &&
                                 relobj.authority == null && relobj.query == null) {
                                 if (relobj.fragment != null) { uriobj.fragment = relobj.fragment; }
                                 relobj = uriobj;
-                        } else if (relobj.scheme == null) {
-                                relobj.scheme = uriobj.scheme;
+                        }
                         
-                                if (relobj.authority == null) {
-                                        relobj.authority = uriobj.authority;
-                                        
-                                        if (relobj.path.charAt(0) != "/") {
-                                                var path = uriobj.path.substring(0,
-                                                        uriobj.path.lastIndexOf("/") + 1) + relobj.path;
-
-                                                var segs = path.split("/");
-                                                for (var j = 0; j < segs.length; j++) {
-                                                        if (segs[j] == ".") {
-                                                                if (j == segs.length - 1) { segs[j] = ""; }
-                                                                else { segs.splice(j, 1); j--; }
-                                                        } else if (j > 0 && !(j == 1 && segs[0] == "") &&
-                                                                segs[j] == ".." && segs[j-1] != "..") {
-
-                                                                if (j == segs.length - 1) { segs.splice(j, 1); segs[j - 1] = ""; }
-                                                                else { segs.splice(j - 1, 2); j -= 2; }
-                                                        }
-                                                }
-                                                relobj.path = segs.join("/");
-                                        }
-                                }
-                        }
-
-                        uri = "";
+                        if (relobj.scheme != null && relobj.authority != null)
+                                uri = "";
                         if (relobj.scheme != null) { uri += relobj.scheme + ":"; }
                         if (relobj.authority != null) { uri += "//" + relobj.authority; }
@@ -72 +48 @@
                         if (relobj.fragment != null) { uri += "#" + relobj.fragment; }
                 }
-
+                
                 this.uri = uri.toString();
 
                 // break the uri into its main components
                 var regexp = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$";
-          var r = this.uri.match(new RegExp(regexp));
+            var r = this.uri.match(new RegExp(regexp));
 
                 this.scheme = r[2] || (r[1] ? "" : null);

branches/i18ndate/tests/date/test_format.js

@@ -1 +1 @@
 // can't set djConfig.extraLocale before bootstrapping unit tests, so manually load resources here for specific locales:
+/**
 dojo.requireLocalization("dojo.i18n.calendar","gregorian","en-us");
 dojo.requireLocalization("dojo.i18n.calendar","gregorian","fr-fr");
 dojo.requireLocalization("dojo.i18n.calendar","gregorian","de-at");
 dojo.requireLocalization("dojo.i18n.calendar","gregorian","ja-jp");
+*/
+
+dojo.requireLocalization("dojo.i18n.calendar","gregorian","en");
+dojo.requireLocalization("dojo.i18n.calendar","gregorian","fr");
+dojo.requireLocalization("dojo.i18n.calendar","gregorian","de");
+dojo.requireLocalization("dojo.i18n.calendar","gregorian","ja");
 
 dojo.require("dojo.date.format");
@@ -156 +163 @@
 
 function test_date_parse() {
-        var tzOffset = new Date().getTimezoneOffset()*60*1000;
-        jum.assertEquals("parse_test1", "1155283200000", dojo.date.parse("08/11/06", {formatLength:'short',selector:'dateOnly', locale:'en-us'}).getTime()+tzOffset);
-}
+        var i = 0;
+        function name() { return "parse_test" + i++; }
+
+        /***********
+         DATES
+        ***********/
+
+        var aug_11_2006 = new Date(2006, 7, 11, 0);
+        var aug_11_06CE = new Date(2006, 7, 11, 0);
+        aug_11_06CE.setFullYear(6); //literally the year 6 C.E.
+
+        //en: 'short' fmt: M/d/yy
+        // Tolerate either 8 or 08 for month part.
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("08/11/06", {formatLength:'short', locale:'en'}));
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("8/11/06", {formatLength:'short', locale:'en'})); 
+        // Tolerate yyyy input in yy part...
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("8/11/2006", {formatLength:'short', locale:'en'}));
+        // ...but not in strict mode
+        jum.assertEquals(name(), null, dojo.date.parse("8/11/2006", {formatLength:'short', locale:'en', strict:true}));
+
+        //en: 'medium' fmt: MMM d, yyyy
+        // Tolerate either 8 or 08 for month part.
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("Aug 11, 2006", {formatLength:'medium', locale:'en'}));
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("Aug 11, 2006", {formatLength:'medium', locale:'en'}));   
+        // Tolerate abbreviating period in month part...
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("Aug. 11, 2006", {formatLength:'medium', locale:'en'}));
+        // ...but not in strict mode
+        jum.assertEquals(name(), null, dojo.date.parse("Aug. 11, 2006", {formatLength:'medium', locale:'en', strict:true}));
+        // Note: 06 for year part will be translated literally as the year 6 C.E.
+        jum.assertEquals(name(), aug_11_06CE, dojo.date.parse("Aug 11, 06", {formatLength:'medium', locale:'en'}));
+        //en: 'long' fmt: MMMM d, yyyy
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("August 11, 2006", {formatLength:'long', locale:'en'}));
+
+        //en: 'full' fmt: EEEE, MMMM d, yyyy
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("Friday, August 11, 2006", {formatLength:'full', locale:'en'}));
+        //TODO: wrong day-of-week should fail
+        //jum.assertEquals(name(), null, dojo.date.parse("Thursday, August 11, 2006", {formatLength:'full', locale:'en'}));
+
+        //Whitespace tolerance
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse(" August 11, 2006", {formatLength:'long', locale:'en'}));
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("August  11, 2006", {formatLength:'long', locale:'en'}));
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("August 11 , 2006", {formatLength:'long', locale:'en'}));
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("August 11,  2006", {formatLength:'long', locale:'en'}));
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("August 11, 2006 ", {formatLength:'long', locale:'en'}));
+
+        //Simple Validation Tests
+        //catch "month" > 12 (note: month/day reversals are common when user expectation isn't met wrt european versus US formats)
+        jum.assertEquals(name(), null, dojo.date.parse("15/1/2005", {formatLength:'short', locale:'en'}));
+        //day of month typo rolls over to the next month
+        jum.assertEquals(name(), null, dojo.date.parse("Aug 32, 2006", {formatLength:'medium', locale:'en'}));
+
+        //Spanish (es)
+        //es: 'short' fmt: d/MM/yy
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("11/08/06", {formatLength:'short', locale:'es'}));
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("11/8/06", {formatLength:'short', locale:'es'})); 
+        // Tolerate yyyy input in yy part...
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("11/8/2006", {formatLength:'short', locale:'es'}));
+        // ...but not in strict mode
+        jum.assertEquals(name(), null, dojo.date.parse("11/8/2006", {formatLength:'short', locale:'es', strict:true}));
+        //es: 'medium' fmt: dd-MMM-yy
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("11-ago-06", {formatLength:'medium', locale:'es'}));
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("11-ago-2006", {formatLength:'medium', locale:'es'}));    
+        // Tolerate abbreviating period in month part...
+        jum.assertEquals(name(), aug_11_2006, dojo.date.parse("11-ago.-2006", {formatLength:'medium', locale:'es'}));
+        // ...but not in strict mode
+        jum.assertEquals(name(), null, dojo.date.parse("11-ago.-2006", {formatLength:'medium', locale:'es', strict:true}));
+        //es: 'long' fmt: d' de 'MMMM' de 'yyyy