Merge lp:~jjacobs/methanal/utc-times into lp:methanal

[Jonathan Jacobs]

[Tristan Seligmann (mithrandi)]

> 7 self._knownTime = Methanal.Util.Time.fromDate(
> 8 - new Date(2009, 8, 6, 1, 36, 23, 2));
> 9 + new Date(2009, 8, 6, 1, 36, 23, 2), true);

As far as I can tell, fromDate only takes one parameter; what is the point of passing true here?

review: Needs Information

[Jonathan Jacobs (jjacobs)]

> > 7 self._knownTime = Methanal.Util.Time.fromDate(
> > 8 - new Date(2009, 8, 6, 1, 36, 23, 2));
> > 9 + new Date(2009, 8, 6, 1, 36, 23, 2), true);
>
> As far as I can tell, fromDate only takes one parameter; what is the point of
> passing true here?

Something left in from an older API. I've removed it and pushed a new revision.

[Tristan Seligmann (mithrandi)]

review: Approve

=== modified file 'methanal/js/Methanal/Tests/TestUtil.js'
--- methanal/js/Methanal/Tests/TestUtil.js	2009-10-02 01:16:09 +0000
+++ methanal/js/Methanal/Tests/TestUtil.js	2009-10-09 22:36:14 +0000
@@ -220,17 +220,20 @@
         function assertTimeParsed(data, timestamp) {
             var time = Methanal.Util.Time.guess(data);
             self.assertIdentical(time._oneDay, true);
-            self.assertIdentical(time.asTimestamp(), timestamp);
+            // User input is interpreted as local time, but the tests should
+            // pass regardless of the runner's local timezone, so we use UTC
+            // dates.
+            self.assertIdentical(time.asUTCDate().getTime(), timestamp);
         };
 
-        assertTimeParsed('2009/9/1',   1251756000000);
-        assertTimeParsed('2009.09.01', 1251756000000);
-        assertTimeParsed('2009-09-01', 1251756000000);
-        assertTimeParsed('1/9/2009',   1251756000000);
-        assertTimeParsed('01.09.2009', 1251756000000);
-        assertTimeParsed('01-09-2009', 1251756000000);
-        assertTimeParsed('1/9/2009',   1251756000000);
-        assertTimeParsed('29/2/2008',  1204236000000);
+        assertTimeParsed('2009/9/1',   1251763200000);
+        assertTimeParsed('2009.09.01', 1251763200000);
+        assertTimeParsed('2009-09-01', 1251763200000);
+        assertTimeParsed('1/9/2009',   1251763200000);
+        assertTimeParsed('01.09.2009', 1251763200000);
+        assertTimeParsed('01-09-2009', 1251763200000);
+        assertTimeParsed('1/9/2009',   1251763200000);
+        assertTimeParsed('29/2/2008',  1204243200000);
     },
 
     
@@ -264,9 +267,9 @@
      * Create a L{Methanal.Util.Time} instance from a C{Date}.
      */
     function test_fromDate(self) {
-        var d = new Date();
+        var d = new Date(2009, 8, 1, 12, 34, 56, 78);
         var t = Methanal.Util.Time.fromDate(d);
-        self.assertIdentical(t.asTimestamp(), d.getTime());
+        self.assertIdentical(t.asDate().getTime(), d.getTime());
     },
 
 
@@ -309,19 +312,32 @@
      * Create a L{Methanal.Util.Time} instance from a timestamp in milliseconds.
      */
     function test_fromTimestamp(self) {
-        var t = Methanal.Util.Time.fromTimestamp(1251759723000);
-        self.assertIdentical(t.asHumanly(), 'Tue, 1 Sep 2009 01:02:03 am');
+        var t;
+        var timestamp;
+
+        timestamp = 1251766923000;
+        t = Methanal.Util.Time.fromTimestamp(timestamp);
+        self.assertIdentical(t.asUTCDate().getTime(), timestamp);
+        self.assertIdentical(t._timezoneOffset, 0);
+
+        var d = new Date();
+        timestamp = d.getTime();
+        t = Methanal.Util.Time.fromTimestamp(timestamp, d.getTimezoneOffset());
+        self.assertIdentical(t.asUTCDate().getTime(), timestamp);
+        self.assertIdentical(
+            t._timezoneOffset, d.getTimezoneOffset() * 60 * 1000);
     },
 
 
     /**
      * L{Methanal.Util.Time.asDate} converts a Time into a C{Date} representing
-     * the same time.
+     * the same I{local} time.
      */
     function test_asDate(self) {
         var t = Methanal.Util.Time();
         var d = t.asDate();
-        self.assertIdentical(t.asTimestamp(), d.getTime());
+        self.assertIdentical(
+            t.asTimestamp() + d.getTimezoneOffset() * 60 * 1000, d.getTime());
     },
 
 
@@ -330,7 +346,7 @@
      * milliseconds elapsed since the epoch.
      */
     function test_asTimestamp(self) {
-        self.assertIdentical(self._knownTime.asTimestamp(), 1252193783002);
+        self.assertIdentical(self._knownTime.asTimestamp(), 1252200983002);
     },
 
 
@@ -392,11 +408,11 @@
      */
     function test_offset(self) {
         var t = self._knownTime.offset(Methanal.Util.TimeDelta({'days': -1}));
-        self.assertIdentical(t.asTimestamp(), 1252107383002);
+        self.assertIdentical(t.asTimestamp(), 1252114583002);
         self.assertIdentical(t.oneDay().asHumanly(), 'Sat, 5 Sep 2009');
 
         var t = self._knownTime.offset(Methanal.Util.TimeDelta({'days': 1}));
-        self.assertIdentical(t.asTimestamp(), 1252280183002);
+        self.assertIdentical(t.asTimestamp(), 1252287383002);
         self.assertIdentical(t.oneDay().asHumanly(), 'Mon, 7 Sep 2009');
     });
 
 
=== modified file 'methanal/js/Methanal/Tests/TestView.js'
--- methanal/js/Methanal/Tests/TestView.js	2009-10-04 11:18:09 +0000
+++ methanal/js/Methanal/Tests/TestView.js	2009-10-09 22:36:14 +0000
@@ -525,8 +525,8 @@
                 self.assertIdentical(called, 0);
                 control.setValue('2009-01-01');
                 self.assertIdentical(called, 1);
-                self.assertIdentical(displayValue,
-                    Methanal.Util.Time.guess('2009-01-01').asHumanly());
+                var t = Methanal.Util.Time.fromDate(new Date(2009, 0, 1));
+                self.assertIdentical(displayValue, t.oneDay().asHumanly());
                 control.onKeyUp(control.inputNode);
                 self.assertIdentical(called, 2);
             });
@@ -548,7 +548,7 @@
                 control.setValue('NOTAVALIDDATE');
                 self.assertIdentical(control.getValue(), undefined);
                 control.setValue('2009-01-01');
-                self.assertIdentical(control.getValue(), 1230760800000);
+                self.assertIdentical(control.getValue(), 1230768000000);
             });
     },
     
 
=== modified file 'methanal/js/Methanal/Util.js'
--- methanal/js/Methanal/Util.js	2009-10-02 01:16:39 +0000
+++ methanal/js/Methanal/Util.js	2009-10-09 22:36:14 +0000
@@ -479,26 +479,37 @@
 
 
 /**
- * A high-level object built on top of C{Date}.
+ * A high-level time and date object.
  *
- * @type _date: C{Date}
- * @ivar _date: Underlying Date instance
+ * @type _timestamp: C{Number}
+ * @ivar _timestamp: Number of milliseconds since the epoch:
+ *     January 1, 1970, 00:00:00 UTC
  *
  * @type _oneDay: C{boolean}
  * @ivar _oneDay: Is this a truncated Time instance?
  */
 Divmod.Class.subclass(Methanal.Util, 'Time').methods(
     function __init__(self) {
-        self._date = new Date();
+        var d = new Date();
+        self._timezoneOffset = d.getTimezoneOffset() * 60 * 1000;
+        self._timestamp = d.getTime() - self._timezoneOffset;
         self._oneDay = false;
     },
 
 
     /**
-     * C{Date} representation.
+     * Local time C{Date} representation.
      */
     function asDate(self) {
-        return self._date;
+        return new Date(self._timestamp + self._timezoneOffset);
+    },
+
+
+    /**
+     * UTC C{Date} representation.
+     */
+    function asUTCDate(self) {
+        return new Date(self._timestamp);
     },
 
 
@@ -506,7 +517,7 @@
      * The number of milliseconds since the epoch.
      */
     function asTimestamp(self) {
-        return self._date.getTime();
+        return self._timestamp;
     },
 
 
@@ -514,7 +525,7 @@
      * A human-readable string representation.
      */
     function asHumanly(self, twentyFourHours) {
-        var _date = self._date;
+        var _date = self.asDate();
         var r = [];
         r.push(self.getDayName(true) + ',');
         r.push(_date.getDate().toString());
@@ -522,28 +533,24 @@
         r.push(_date.getFullYear().toString());
 
         if (!self._oneDay) {
-            function _humanlyTime(dateWithTime, twentyFourHours) {
-                var prefix = '';
-                var hours = dateWithTime.getHours();
-                if (!twentyFourHours) {
-                    var dm = Methanal.Util.divmod(hours, 12);
-                    prefix = dm[0] > 0 ? ' pm' : ' am';
-                    hours = dm[1] == 0 ? 12 : dm[1];
-                }
-
-                function pad(v) {
-                    return Methanal.Util.rjust(v.toString(), 2, '0');
-                };
-
-                var r = [];
-                r.push(hours);
-                r.push(dateWithTime.getMinutes());
-                r.push(dateWithTime.getSeconds());
-                r = Methanal.Util.map(pad, r);
-                return r.join(':') + prefix;
+            var prefix = '';
+            var hours = _date.getHours();
+            if (!twentyFourHours) {
+                var dm = Methanal.Util.divmod(hours, 12);
+                prefix = dm[0] > 0 ? ' pm' : ' am';
+                hours = dm[1] == 0 ? 12 : dm[1];
             }
 
-            r.push(_humanlyTime(_date, twentyFourHours));
+            function pad(v) {
+                return Methanal.Util.rjust(v.toString(), 2, '0');
+            };
+
+            var t = [];
+            t.push(hours);
+            t.push(_date.getMinutes());
+            t.push(_date.getSeconds());
+            t = Methanal.Util.map(pad, t);
+            r.push(t.join(':') + prefix);
         }
 
         return r.join(' ');
@@ -559,7 +566,7 @@
      * @rtype: C{String}
      */
     function getDayName(self, shortened) {
-        var name = Methanal.Util.Time._dayNames[self._date.getDay()];
+        var name = Methanal.Util.Time._dayNames[self.asDate().getDay()];
         return shortened ? name.substr(0, 3) : name;
     },
 
@@ -573,7 +580,7 @@
      * @rtype: C{String}
      */
     function getMonthName(self, shortened) {
-        var name = Methanal.Util.Time._monthNames[self._date.getMonth()];
+        var name = Methanal.Util.Time._monthNames[self.asDate().getMonth()];
         return shortened ? name.substr(0, 3) : name;
     },
 
@@ -585,11 +592,12 @@
      * @return: A new instance representing the truncated date
      */
     function oneDay(self) {
-        var d = new Date(
-            self._date.getFullYear(),
-            self._date.getMonth(),
-            self._date.getDate());
-        var t = Methanal.Util.Time.fromDate(d);
+        var _date = self.asDate();
+        _date.setHours(0);
+        _date.setMinutes(0);
+        _date.setSeconds(0);
+        _date.setMilliseconds(0);
+        var t = Methanal.Util.Time.fromDate(_date);
         t._oneDay = true;
         return t;
     },
@@ -606,9 +614,9 @@
      * @return: A new instance representing the newly offset time
      */
     function offset(self, delta) {
-        var d = new Date(self.asTimestamp() + delta);
-        var t = Methanal.Util.Time.fromDate(d);
+        var t = Methanal.Util.Time.fromTimestamp(self.asTimestamp() + delta);
         t._oneDay = self._oneDay;
+        t._timezoneOffset = self._timezoneOffset;
         return t;
     });
 
@@ -628,17 +636,35 @@
  */
 Methanal.Util.Time.fromDate = function fromDate(dateObj) {
     var t = Methanal.Util.Time();
-    t._date = dateObj;
+    t._timezoneOffset = dateObj.getTimezoneOffset() * 60 * 1000;
+    t._timestamp = dateObj.getTime() - t._timezoneOffset;
     return t;
 };
 
 
 
 /**
- * Create a L{Methanal.Util.Time} instance from a timestamp in milliseconds.
+ * Create a L{Methanal.Util.Time} instance from a timestamp in milliseconds,
+ * since January 1, 1970, 00:00:00 UTC.
+ *
+ * @type  timestamp: C{Number}
+ * @param timestamp: Number of milliseconds since the epoch
+ *
+ * @type  timezoneOffset: C{Number}
+ * @param timezoneOffset: Timezone offset in minutes
+ *
+ * @rtype: L{Methanal.Util.Time}
  */
-Methanal.Util.Time.fromTimestamp = function fromTimestamp(timestamp) {
-    return Methanal.Util.Time.fromDate(new Date(timestamp));
+Methanal.Util.Time.fromTimestamp = function fromTimestamp(timestamp, timezoneOffset) {
+    var t = Methanal.Util.Time();
+    t._timestamp = timestamp;
+    if (timezoneOffset) {
+        timezoneOffset *= 60 * 1000;
+    } else {
+        timezoneOffset = 0;
+    }
+    t._timezoneOffset = timezoneOffset;
+    return t;
 };
 
 
@@ -715,6 +741,9 @@
 /**
  * Create a L{Methanal.Util.Time} instance from a semi-structured string.
  *
+ * As this is primarily intended for textual date input by users, L{value} is
+ * interpreted in local time.
+ *
  * @type  value: C{String}
  * @param value: Either a numerical YYYYMMDD or DDMMYYY string (separated by
  *     C{/}, C{.} or C{-}) or a relative time reference, as supported by
@@ -759,10 +788,11 @@
             y = Methanal.Util.strToInt(parts[2]);
         }
 
-        if (_validDate(y, m, d))
+        if (_validDate(y, m, d)) {
             // TODO: In the future, "guess" should be able to guess times as
             // well as dates.
             return Methanal.Util.Time.fromDate(new Date(y, m, d)).oneDay();
+        }
     }
 
     throw new Methanal.Util.TimeParseError(
 
=== modified file 'methanal/js/Methanal/View.js'
--- methanal/js/Methanal/View.js	2009-10-05 00:15:43 +0000
+++ methanal/js/Methanal/View.js	2009-10-09 22:36:14 +0000
@@ -1605,7 +1605,13 @@
     function makeDisplayValue(self, value) {
         var msg = '';
         try {
-            var time = Methanal.Util.Time.fromTimestamp(value).oneDay();
+            // XXX: There is probably a potential bug here: If "value" (a UTC
+            // timestamp) falls before the switch-over for daylight savings
+            // before the timezone offset has been corrected for, the timezone
+            // offset given here will be the wrong one.
+            var d = new Date(value);
+            var time = Methanal.Util.Time.fromTimestamp(
+                value, d.getTimezoneOffset()).oneDay();
             if (time) {
                 msg = time.asHumanly(self.twentyFourHours);
             }