Skip to main content

hypermail/
date.rs

1use crate::error::{HypermailError, Result};
2use crate::i18n::I18n;
3use chrono::{DateTime, FixedOffset, NaiveDateTime, Offset, TimeZone, Utc};
4use std::sync::LazyLock;
5
6pub const MONTHS: &[&str] = &[
7    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
8];
9
10pub const DAYS: &[&str] = &["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
11
12/// Replace English day/month abbreviations in a formatted date string with localized equivalents
13/// using the locale JSON files.
14pub fn localize_date_str(date_str: &str, lang: &str) -> String {
15    if lang == "en" {
16        return date_str.to_string();
17    }
18    let i18n = I18n::new(lang);
19    let mut result = date_str.to_string();
20
21    // Replace day abbreviations
22    for &en_day in DAYS {
23        let localized = i18n.get(en_day);
24        if localized != en_day && result.contains(en_day) {
25            result = result.replacen(en_day, localized, 1);
26            break;
27        }
28    }
29
30    // Replace month abbreviations
31    for &en_month in MONTHS {
32        let localized = i18n.get(en_month);
33        if localized != en_month && result.contains(en_month) {
34            result = result.replacen(en_month, localized, 1);
35            break;
36        }
37    }
38
39    result
40}
41
42pub fn is_leap(y: i32) -> bool {
43    y > 1752 && (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
44}
45
46pub fn month_from_str(s: &str) -> Option<u32> {
47    MONTHS.iter().position(|&m| m.eq_ignore_ascii_case(s)).map(|p| (p + 1) as u32)
48}
49
50pub fn parse_rfc2822_date(s: &str) -> Result<i64> {
51    let s = s.trim();
52
53    let parsed = DateTime::parse_from_rfc2822(s);
54    if let Ok(dt) = parsed {
55        return Ok(dt.timestamp());
56    }
57
58    try_parse_flexible(s)
59}
60
61fn try_parse_flexible(s: &str) -> Result<i64> {
62    let s = s.trim().to_string();
63
64    if let Ok(dt) = DateTime::parse_from_rfc3339(&s) {
65        return Ok(dt.timestamp());
66    }
67
68    let cleaned = s.replace(" (", "(").replace(") ", ")").trim().to_string();
69
70    if let Ok(dt) = DateTime::parse_from_rfc2822(&cleaned) {
71        return Ok(dt.timestamp());
72    }
73
74    // Normalize non-standard timezone suffixes like "GMT+2", "GMT-5", "UTC+3"
75    // into offset form "+0200" that chrono can parse.
76    let normalized = normalize_nonstandard_tz(&cleaned);
77    if normalized != cleaned {
78        if let Ok(dt) = DateTime::parse_from_rfc2822(&normalized) {
79            return Ok(dt.timestamp());
80        }
81    }
82
83    if let Ok(naive) = NaiveDateTime::parse_from_str(&cleaned, "%a %b %d %H:%M:%S %Y") {
84        if let Some(local) = LocalFixOffset::local_to_fixed(naive) {
85            return Ok(local.timestamp());
86        }
87    }
88
89    if let Ok(naive) = chrono::NaiveDate::parse_from_str(&cleaned, "%Y-%m-%d")
90        .map(|d| d.and_hms_opt(0, 0, 0).unwrap())
91    {
92        if let Some(local) = LocalFixOffset::local_to_fixed(naive) {
93            return Ok(local.timestamp());
94        }
95    }
96
97    Err(HypermailError::DateParse(format!("Cannot parse date: {}", s)))
98}
99
100/// Convert trailing `GMT+N`, `GMT-N`, `UTC+N`, `UTC-N` (and fractional-hour forms like `GMT+5:30`)
101/// into an RFC 2822-compatible numeric offset (`+HHMM` / `-HHMM`).
102fn normalize_nonstandard_tz(s: &str) -> String {
103    // Match pattern: ...whitespace(GMT|UTC)(+|-)H or HH or H:MM or HH:MM at end
104    let re = LazyLock::force(&NONSTANDARD_TZ_RE);
105    if let Some(cap) = re.captures(s) {
106        let sign = &cap[1];
107        let hours_str = &cap[2];
108        let mins_str = cap.get(3).map(|m| m.as_str()).unwrap_or("00");
109        let hours: i32 = hours_str.parse().unwrap_or(0);
110        let mins: i32 = mins_str.parse().unwrap_or(0);
111        let offset = format!("{}{:02}{:02}", sign, hours, mins);
112        // Replace the matched GMT/UTC+N suffix with the numeric offset
113        let match_start = cap.get(0).unwrap().start();
114        // Keep everything before the GMT/UTC sign, append the offset
115        let base = &s[..match_start];
116        return format!("{}{}", base.trim_end(), offset.replace("+", " +").replace("-", " -"));
117    }
118    s.to_string()
119}
120
121static NONSTANDARD_TZ_RE: std::sync::LazyLock<regex::Regex> = std::sync::LazyLock::new(|| {
122    regex::Regex::new(r"(?i)(?:GMT|UTC)([+-])(\d{1,2})(?::(\d{2}))?$").unwrap()
123});
124
125struct LocalFixOffset;
126
127impl LocalFixOffset {
128    fn local_to_fixed(naive: NaiveDateTime) -> Option<DateTime<FixedOffset>> {
129        let local_offset = chrono::Local::now().offset().fix();
130        match FixedOffset::east_opt(local_offset.local_minus_utc()) {
131            Some(fixed) => fixed.from_local_datetime(&naive).single(),
132            None => None,
133        }
134    }
135}
136
137/// Clamp a Unix timestamp to chrono's valid range to prevent panics.
138/// chrono supports roughly -262144-01-01 to +262143-12-31, but we clamp
139/// to a practical range: 0000-01-01 to 9999-12-31.
140fn clamp_timestamp(timestamp: i64) -> i64 {
141    const MIN_TS: i64 = -62167219200; // 0000-01-01T00:00:00Z
142    const MAX_TS: i64 = 253402300799; // 9999-12-31T23:59:59Z
143    timestamp.clamp(MIN_TS, MAX_TS)
144}
145
146pub fn get_date_str(
147    timestamp: i64,
148    fmt: Option<&str>,
149    gmtime: bool,
150    eurodate: bool,
151    isodate: bool,
152    lang: &str,
153) -> String {
154    let timestamp = clamp_timestamp(timestamp);
155    let dt: DateTime<FixedOffset> = if gmtime {
156        FixedOffset::east_opt(0).unwrap().from_utc_datetime(
157            &Utc.timestamp_opt(timestamp, 0).single().unwrap_or_default().naive_utc(),
158        )
159    } else {
160        match chrono::Local.timestamp_opt(timestamp, 0).single() {
161            Some(local) => {
162                let offset = *local.offset();
163                let naive = local.naive_local();
164                FixedOffset::east_opt(offset.local_minus_utc())
165                    .unwrap()
166                    .from_local_datetime(&naive)
167                    .single()
168                    .unwrap_or_else(|| {
169                        FixedOffset::east_opt(0)
170                            .unwrap()
171                            .from_utc_datetime(&naive.and_utc().naive_utc())
172                    })
173            },
174            None => {
175                // Fallback for timestamps that can't be resolved to local time
176                FixedOffset::east_opt(0).unwrap().from_utc_datetime(
177                    &Utc.timestamp_opt(timestamp, 0).single().unwrap_or_default().naive_utc(),
178                )
179            },
180        }
181    };
182
183    let raw = if let Some(format_str) = fmt {
184        // invalid user format (e.g. "%Q") makes Display error; to_string() would panic
185        let mut s = String::new();
186        if std::fmt::Write::write_fmt(&mut s, format_args!("{}", dt.format(format_str))).is_err() {
187            s = dt.to_rfc2822();
188        }
189        s
190    } else if isodate {
191        if gmtime {
192            dt.format("%Y-%m-%d %H:%M:%SZ").to_string()
193        } else {
194            dt.format("%Y-%m-%d %H:%M:%S").to_string()
195        }
196    } else if eurodate {
197        dt.format("%a %d %b %Y %H:%M:%S %z").to_string()
198    } else {
199        dt.format("%a %b %d %Y %H:%M:%S %z").to_string()
200    };
201
202    localize_date_str(&raw, lang)
203}
204
205pub fn secs_to_iso(timestamp: i64) -> String {
206    let timestamp = clamp_timestamp(timestamp);
207    let dt = Utc.timestamp_opt(timestamp, 0).single().unwrap_or_default();
208    dt.format("%Y-%m-%dT%H:%M:%SZ").to_string()
209}
210
211pub fn iso_to_secs(s: &str) -> Result<i64> {
212    let cleaned = s.trim();
213    if let Ok(dt) = DateTime::parse_from_rfc3339(cleaned) {
214        return Ok(dt.timestamp());
215    }
216    if let Ok(dt) = NaiveDateTime::parse_from_str(cleaned, "%Y-%m-%dT%H:%M:%S") {
217        return Ok(dt.and_utc().timestamp());
218    }
219    Err(HypermailError::DateParse(format!("Cannot parse ISO date: {}", s)))
220}
221
222pub fn get_timezone_str() -> String {
223    let offset = chrono::Local::now().offset().fix();
224    let total_secs = offset.local_minus_utc();
225    let hours = total_secs / 3600;
226    let mins = (total_secs.abs() / 60) % 60;
227    if total_secs >= 0 {
228        format!("+{:02}{:02}", hours, mins)
229    } else {
230        format!("-{:02}{:02}", -hours, mins)
231    }
232}
233
234#[cfg(test)]
235mod tests {
236    use super::*;
237    use chrono::Timelike;
238
239    #[test]
240    fn test_invalid_format_no_panic() {
241        let ds = get_date_str(1615809600, Some("%Q"), true, false, false, "en");
242        assert!(ds.contains("2021"), "fallback should still show the date: {ds}");
243    }
244
245    #[test]
246    fn test_parse_rfc2822() {
247        let ts = parse_rfc2822_date("Mon, 15 Mar 2021 12:00:00 +0000").unwrap();
248        assert_eq!(ts, 1615809600);
249
250        let ts = parse_rfc2822_date("15 Mar 2021 12:00:00 +0000").unwrap();
251        assert_eq!(ts, 1615809600);
252
253        let ts = parse_rfc2822_date("Mon, 15 Mar 2021 12:00:00 GMT").unwrap();
254        assert_eq!(ts, 1615809600);
255    }
256
257    #[test]
258    fn test_parse_various_dates() {
259        assert!(parse_rfc2822_date("Thu, 01 Jan 1998 00:00:00 +0000").is_ok());
260        assert!(parse_rfc2822_date("1 Jan 1998 00:00:00 +0000").is_ok());
261        assert!(parse_rfc2822_date("1 Jan 1998 00:00:00 +0100 (CET)").is_ok());
262        assert!(parse_rfc2822_date("Tue, 1 Jul 2003 10:52:37 +1200").is_ok());
263    }
264
265    #[test]
266    fn test_date_roundtrip() {
267        let original = "Mon, 15 Mar 2021 12:00:00 +0000";
268        let ts = parse_rfc2822_date(original).unwrap();
269        let formatted = secs_to_iso(ts);
270        assert!(formatted.starts_with("2021-03-15T12:00:00"));
271    }
272
273    #[test]
274    fn test_date_str() {
275        let ts = 1615809600; // 2021-03-15 12:00:00 UTC
276                             // Default (US): month before day
277        let ds = get_date_str(ts, None, true, false, false, "en");
278        assert_eq!(ds, "Mon Mar 15 2021 12:00:00 +0000");
279    }
280
281    #[test]
282    fn test_isodate_str() {
283        let ts = 1615809600;
284        let ds = get_date_str(ts, None, true, false, true, "en");
285        assert!(ds.contains("2021-03-15"));
286    }
287
288    #[test]
289    fn test_iso_roundtrip() {
290        let ts = 1615809600;
291        let iso = secs_to_iso(ts);
292        let back = iso_to_secs(&iso).unwrap();
293        assert_eq!(ts, back);
294    }
295
296    #[test]
297    fn test_month_from_str() {
298        assert_eq!(month_from_str("Jan"), Some(1));
299        assert_eq!(month_from_str("jan"), Some(1));
300        assert_eq!(month_from_str("Dec"), Some(12));
301        assert_eq!(month_from_str("Foo"), None);
302    }
303
304    #[test]
305    fn test_invalid_date() {
306        assert!(parse_rfc2822_date("").is_err());
307        assert!(parse_rfc2822_date("not a date").is_err());
308    }
309
310    #[test]
311    fn test_localize_date_greek() {
312        let ts = 1615809600; // Mon Mar 15 2021
313        let ds = get_date_str(ts, None, true, false, false, "el");
314        assert!(ds.contains("Δευ"), "Expected Greek Monday abbreviation, got: {}", ds);
315        assert!(ds.contains("Μαρ"), "Expected Greek March abbreviation, got: {}", ds);
316    }
317
318    #[test]
319    fn test_localize_date_german() {
320        let ts = 1615809600;
321        let ds = get_date_str(ts, None, true, false, false, "de");
322        assert!(ds.contains("Mo"), "Expected German Monday abbreviation, got: {}", ds);
323        assert!(ds.contains("Mär"), "Expected German March abbreviation, got: {}", ds);
324    }
325
326    #[test]
327    fn test_localize_date_unknown_lang_falls_back() {
328        let ts = 1615809600;
329        let ds = get_date_str(ts, None, true, false, false, "xx");
330        assert!(ds.contains("Mon"), "Unknown lang should keep English, got: {}", ds);
331    }
332
333    #[test]
334    fn test_parse_gmt_plus_offset() {
335        // "GMT+2" style non-standard timezone — seen in old 1996 emails
336        let ts = parse_rfc2822_date("Mon, 12 Feb 1996 15:24:04 GMT+2");
337        assert!(ts.is_ok(), "GMT+2 should parse successfully, got: {:?}", ts);
338        let t = ts.unwrap();
339        // 1996-02-12 15:24:04 at +02:00 = 13:24:04 UTC
340        let dt = chrono::Utc.timestamp_opt(t, 0).unwrap();
341        assert_eq!(dt.hour(), 13, "Expected 13:24 UTC, got {:?}", dt);
342        assert_eq!(dt.minute(), 24);
343    }
344
345    #[test]
346    fn test_parse_gmt_minus_offset() {
347        let ts = parse_rfc2822_date("Wed, 01 May 1996 08:00:00 GMT-5");
348        assert!(ts.is_ok(), "GMT-5 should parse, got: {:?}", ts);
349        let t = ts.unwrap();
350        let dt = chrono::Utc.timestamp_opt(t, 0).unwrap();
351        assert_eq!(dt.hour(), 13); // 08:00 + 05:00 = 13:00 UTC
352    }
353
354    #[test]
355    fn test_parse_utc_plus_fractional_offset() {
356        let ts = parse_rfc2822_date("Thu, 01 Jan 1998 12:00:00 UTC+5:30");
357        assert!(ts.is_ok(), "UTC+5:30 should parse, got: {:?}", ts);
358        let t = ts.unwrap();
359        let dt = chrono::Utc.timestamp_opt(t, 0).unwrap();
360        assert_eq!(dt.hour(), 6); // 12:00 - 05:30 = 06:30 UTC
361        assert_eq!(dt.minute(), 30);
362    }
363
364    #[test]
365    fn test_is_leap_year() {
366        assert!(is_leap(2000));
367        assert!(is_leap(2004));
368        assert!(!is_leap(1900));
369        assert!(!is_leap(2001));
370    }
371
372    #[test]
373    fn test_is_leap_before_1752() {
374        // Gregorian calendar reform: years <= 1752 are always false
375        assert!(!is_leap(1600));
376        assert!(!is_leap(1752));
377    }
378
379    #[test]
380    fn test_get_timezone_str_format() {
381        let tz = get_timezone_str();
382        assert!(tz.starts_with('+') || tz.starts_with('-'), "Expected +/- prefix, got: {}", tz);
383        assert_eq!(tz.len(), 5, "Expected ±HHMM (5 chars), got: {}", tz);
384    }
385
386    #[test]
387    fn test_eurodate_str() {
388        let ts = 1615809600; // Mon Mar 15 2021 12:00:00 UTC
389        let ds = get_date_str(ts, None, true, true, false, "en");
390        assert_eq!(ds, "Mon 15 Mar 2021 12:00:00 +0000");
391    }
392
393    #[test]
394    fn test_custom_format_str() {
395        let ts = 1615809600;
396        let ds = get_date_str(ts, Some("%Y-%m-%d"), true, false, false, "en");
397        assert_eq!(ds, "2021-03-15");
398    }
399}