Bug mime date parse (#50)

The original problem was a failing test, described as:

> This commit fixes a bug in MIME date parsing related to named
timezones (like "MST"). The issue is that Go's `time.Parse` handles
named timezone abbreviations inconsistently across platforms - on some
systems the offset is known, on others it's not. The fix detects whether
a date string contains a numeric offset (e.g., `+0700`, `-05:00`) or `Z`
(UTC), and handles conversion differently:

However, the fix needed an additional fix:

> When parseDate falls back to parsing the original string (with
parenthesized timezone), it was using the numericOffset computed from
baseStr instead of the original string. This caused incorrect UTC
conversion for dates like "Mon, 02 Jan 2006 15:04:05 +0700 (UTC)" where
the baseStr has no offset but the original string does.

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: hughdbrown

internal/mime/parse.go

@@ -221,8 +221,35 @@ var dateFormats = []string{
 	"2006-01-02 15:04:05",                   // SQL-like without TZ
 }
 
+// numericOffsetRe matches numeric timezone offsets like +0000, -0700, +00:00, -07:00
+var numericOffsetRe = regexp.MustCompile(`[+-]\d{2}:?\d{2}`)
+
+// hasNumericOffset returns true if the string contains a numeric timezone offset or Z (UTC).
+// Named timezones like "MST" have platform-dependent behavior in Go's time.Parse,
+// so we need to handle them specially.
+func hasNumericOffset(s string) bool {
+	if strings.HasSuffix(s, "Z") {
+		return true
+	}
+	return numericOffsetRe.MatchString(s)
+}
+
+// toUTC converts a time to UTC. If the original had a numeric offset, perform
+// proper timezone conversion. Otherwise (named timezone only), keep the same
+// local time values but mark them as UTC (since named TZ offsets are unreliable
+// across platforms).
+func toUTC(t time.Time, numericOffset bool) time.Time {
+	if numericOffset {
+		return t.UTC()
+	}
+	// Named timezone: keep same time values, mark as UTC
+	return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), time.UTC)
+}
+
 // parseDate attempts to parse a date string in various formats.
 // Returns the time in UTC for consistent storage.
+// Named timezones (like "MST") are treated as UTC since their offsets
+// can't be reliably determined across platforms.
 func parseDate(s string) (time.Time, error) {
 	// Normalize whitespace efficiently: split on whitespace runs and rejoin
 	s = strings.Join(strings.Fields(s), " ")
@@ -234,18 +261,23 @@ func parseDate(s string) (time.Time, error) {
 		baseStr = strings.TrimSpace(s[:idx])
 	}
 
+	// Check if we have a numeric offset for proper UTC conversion
+	numericOffset := hasNumericOffset(baseStr)
+
 	// Try parsing with base string (parenthesized TZ stripped)
 	for _, format := range dateFormats {
 		if t, err := time.Parse(format, baseStr); err == nil {
-			return t.UTC(), nil
+			return toUTC(t, numericOffset), nil
 		}
 	}
 
 	// Try original string (some formats expect the parenthesized part)
 	if baseStr != s {
 		for _, format := range dateFormats {
 			if t, err := time.Parse(format, s); err == nil {
-				return t.UTC(), nil
+				// Recompute numericOffset for the original string since it may
+				// have a different offset than baseStr (e.g., "+0700 (UTC)")
+				return toUTC(t, hasNumericOffset(s)), nil
 			}
 		}
 	}

internal/mime/parse_test.go

@@ -100,6 +100,85 @@ func TestParseReferences(t *testing.T) {
 	}
 }
 
+func TestHasNumericOffset(t *testing.T) {
+	tests := []struct {
+		input string
+		want  bool
+	}{
+		// Numeric offsets should return true
+		{"+0700", true},
+		{"-0700", true},
+		{"+07:00", true},
+		{"-07:00", true},
+		{"Mon, 02 Jan 2006 15:04:05 -0700", true},
+		{"Mon, 02 Jan 2006 15:04:05 +0000", true},
+		{"2006-01-02T15:04:05-07:00", true},
+		{"2006-01-02T15:04:05+00:00", true},
+
+		// Z suffix (UTC) should return true
+		{"2006-01-02T15:04:05Z", true},
+		{"Z", true},
+
+		// Named timezones should return false
+		{"MST", false},
+		{"Mon, 02 Jan 2006 15:04:05 MST", false},
+		{"Mon, 02 Jan 2006 15:04:05 PST", false},
+		{"Mon Jan 2 15:04:05 MST 2006", false},
+
+		// Mixed: numeric offset with parenthesized named TZ should return true
+		{"Mon, 02 Jan 2006 15:04:05 -0700 (PST)", true},
+		{"Mon, 02 Jan 2006 15:04:05 +0700 (UTC)", true},
+
+		// Empty and no timezone
+		{"", false},
+		{"Mon, 02 Jan 2006 15:04:05", false},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.input, func(t *testing.T) {
+			got := hasNumericOffset(tc.input)
+			if got != tc.want {
+				t.Errorf("hasNumericOffset(%q) = %v, want %v", tc.input, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestToUTC(t *testing.T) {
+	// Test with numeric offset: should perform proper timezone conversion
+	t.Run("numeric offset converts to UTC", func(t *testing.T) {
+		// Create a time at 15:04:05 in -0700 timezone
+		loc := time.FixedZone("test", -7*60*60)
+		input := time.Date(2006, 1, 2, 15, 4, 5, 0, loc)
+
+		got := toUTC(input, true)
+
+		// Should be 22:04:05 UTC (15:04:05 + 7 hours)
+		want := time.Date(2006, 1, 2, 22, 4, 5, 0, time.UTC)
+		if !got.Equal(want) {
+			t.Errorf("toUTC() with numeric offset = %v, want %v", got, want)
+		}
+	})
+
+	// Test with named timezone: should keep same time values but mark as UTC
+	t.Run("named timezone keeps same values as UTC", func(t *testing.T) {
+		// Create a time at 15:04:05 with some location
+		loc := time.FixedZone("test", -7*60*60)
+		input := time.Date(2006, 1, 2, 15, 4, 5, 0, loc)
+
+		got := toUTC(input, false)
+
+		// Should be 15:04:05 UTC (same wall-clock time, different instant)
+		want := time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)
+		if !got.Equal(want) {
+			t.Errorf("toUTC() with named timezone = %v, want %v", got, want)
+		}
+		if got.Location() != time.UTC {
+			t.Errorf("toUTC() location = %v, want UTC", got.Location())
+		}
+	})
+}
+
 func TestParseDate(t *testing.T) {
 	// parseDate returns zero time (not error) for unparseable dates.
 	// This is intentional - malformed dates are common in email and
@@ -110,26 +189,44 @@ func TestParseDate(t *testing.T) {
 		input string
 		want  time.Time // Zero value means we expect parse failure
 	}{
-		// Valid RFC date formats
+		// Valid RFC date formats with numeric offsets
 		{"RFC1123Z", "Mon, 02 Jan 2006 15:04:05 -0700",
 			time.Date(2006, 1, 2, 22, 4, 5, 0, time.UTC)},
-		{"RFC1123 named zone", "Mon, 2 Jan 2006 15:04:05 MST",
-			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)}, // MST treated as UTC offset 0 by Go
 		{"no weekday", "02 Jan 2006 15:04:05 -0700",
 			time.Date(2006, 1, 2, 22, 4, 5, 0, time.UTC)},
 		{"parenthesized zone", "Mon, 02 Jan 2006 15:04:05 -0700 (PST)",
 			time.Date(2006, 1, 2, 22, 4, 5, 0, time.UTC)},
 		{"double space after comma", "Mon,  2 Dec 2024 11:42:03 +0000 (UTC)",
 			time.Date(2024, 12, 2, 11, 42, 3, 0, time.UTC)},
-		{"ISO 8601 UTC", "2006-01-02T15:04:05Z",
-			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
 		{"ISO 8601 offset", "2006-01-02T15:04:05-07:00",
 			time.Date(2006, 1, 2, 22, 4, 5, 0, time.UTC)},
 		{"SQL-like with tz", "2006-01-02 15:04:05 -0700",
 			time.Date(2006, 1, 2, 22, 4, 5, 0, time.UTC)},
+
+		// Z suffix (UTC) - should work like numeric offset
+		{"ISO 8601 UTC", "2006-01-02T15:04:05Z",
+			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
+
+		// Named timezone handling - time values kept as-is, marked UTC
+		// Named TZ offsets are platform-dependent, so we treat them as UTC
+		{"RFC1123 named zone MST", "Mon, 2 Jan 2006 15:04:05 MST",
+			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
+		{"single-digit day named zone", "Mon, 2 Jan 2006 15:04:05 PST",
+			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
+		{"no weekday named zone", "02 Jan 2006 15:04:05 EST",
+			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
+		{"UnixDate format", "Mon Jan  2 15:04:05 MST 2006",
+			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
+
+		// No timezone at all - treated like named TZ (no offset to convert)
 		{"SQL-like no tz", "2006-01-02 15:04:05",
 			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
 
+		// Edge case: parenthesized TZ differs from main TZ
+		// The numeric offset (+0700) should be used for conversion
+		{"numeric offset with different paren TZ", "Mon, 02 Jan 2006 15:04:05 +0700 (UTC)",
+			time.Date(2006, 1, 2, 8, 4, 5, 0, time.UTC)},
+
 		// Invalid/unparseable dates should return zero time
 		{"empty", "", time.Time{}},
 		{"garbage", "not a date", time.Time{}},