chrono-node-rs 0.1.0

Behaviour-matched Rust port of chrono-node: natural-language date parsing, checked against chrono-node's own output
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! upstream `locales/vi/parsers/VITimeExpressionParser.ts`.

use crate::common::word_boundary::{WithWordBoundary, WordBoundaryParser};
use crate::core::chrono::{Extracted, Parser};
use crate::core::components::{meridiem, Component};
use crate::core::configuration::Flags;
use crate::core::context::ParsingContext;
use crate::core::regex::{JsRegex, RegexMatch};
use crate::core::utils::js::js_parse_int;
use crate::js_regex;

pub const UPSTREAM: &str = "VITimeExpressionParser";

pub fn create(_flags: &Flags) -> Box<dyn Parser> {
    Box::new(WithWordBoundary::new(ViTimeExpressionParser))
}

const HOUR_GROUP: usize = 1;
const MINUTE_GIO_GROUP: usize = 2;
const MERIDIEM_GROUP: usize = 3;
const MINUTE_COLON_GROUP: usize = 4;

struct ViTimeExpressionParser;

/// JS truthiness of `match[i]`: `undefined` and `""` are false.
fn truthy(m: &RegexMatch, i: usize) -> Option<&str> {
    m.get(i).filter(|s| !s.is_empty())
}

impl WordBoundaryParser for ViTimeExpressionParser {
    fn inner_pattern(&self, _context: &ParsingContext) -> JsRegex {
        // lúc 7 giờ 30 phút  |  7 giờ sáng  |  7 giờ  |  15:30
        js_regex!(
            concat!(
                r"(?:lúc\s*|vào\s*)?",
                r"([0-9]{1,2})",
                r"(?:\s*giờ\s*([0-9]{1,2})?\s*(?:phút\s*)?",
                r"(sáng|trưa|chiều|tối|đêm)?",
                r"|:([0-9]{2}))",
                r"(?=\W|$)",
            ),
            "i"
        )
        .clone()
    }

    fn inner_extract(&self, context: &ParsingContext, m: &mut RegexMatch) -> Extracted {
        // `hour > 23` is false for NaN; the group is always digits here.
        let Some(hour) = js_parse_int(m.get(HOUR_GROUP).unwrap_or("")) else {
            return Extracted::None;
        };
        if hour > 23 {
            return Extracted::None;
        }

        let mut result = context.create_parsing_result(m.index, m.text(), None, None);
        result.start.assign(Component::Hour, hour);

        let minute = if let Some(s) = truthy(m, MINUTE_COLON_GROUP) {
            js_parse_int(s)
        } else if let Some(s) = truthy(m, MINUTE_GIO_GROUP) {
            js_parse_int(s)
        } else {
            Some(0)
        };
        let Some(minute) = minute else {
            return Extracted::None;
        };
        if minute >= 60 {
            return Extracted::None;
        }
        result.start.assign(Component::Minute, minute);

        let mer = m.get(MERIDIEM_GROUP).map(|s| s.to_lowercase());
        match mer.as_deref() {
            Some("sáng") => {
                // "12 giờ sáng" = midnight (00:00), matching EN convention
                result.start.assign(Component::Meridiem, meridiem::AM);
                if hour == 12 {
                    result.start.assign(Component::Hour, 0);
                }
            }
            Some("trưa") => {
                // "1 giờ trưa" = 13:00, but "11 giờ trưa" = 11:00 (approaching noon)
                if hour < 10 {
                    result.start.assign(Component::Meridiem, meridiem::PM);
                    result.start.assign(Component::Hour, hour + 12);
                } else {
                    // 10-12: keep as-is (AM for 10-11, PM for 12)
                    result
                        .start
                        .assign(Component::Meridiem, if hour >= 12 { meridiem::PM } else { meridiem::AM });
                }
            }
            Some("chiều") | Some("tối") | Some("đêm") => {
                result.start.assign(Component::Meridiem, meridiem::PM);
                if hour < 12 {
                    result.start.assign(Component::Hour, hour + 12);
                }
            }
            _ => {}
        }

        result.start.imply(Component::Second, 0);
        result.start.imply(Component::Millisecond, 0);
        Extracted::Result(result)
    }
}