chrono-node-rs 0.1.0

//! upstream `locales/it/parsers/ITTimeExpressionParser.ts`.

use crate::common::time_expression::{self, TimeExpression, TimeExpressionParser};
use crate::core::chrono::Parser;
use crate::core::components::{meridiem, Component, ParsingComponents};
use crate::core::configuration::Flags;
use crate::core::context::ParsingContext;
use crate::core::regex::RegexMatch;
use crate::core::result::ParsingResult;
use crate::js_regex;

pub const UPSTREAM: &str = "ITTimeExpressionParser";

pub fn create(flags: &Flags) -> Box<dyn Parser> {
    Box::new(TimeExpression::new(ItTimeExpressionParser { strict_mode: flags.get("strictMode") }))
}

struct ItTimeExpressionParser {
    strict_mode: bool,
}

impl TimeExpressionParser for ItTimeExpressionParser {
    fn strict_mode(&self) -> bool {
        self.strict_mode
    }

    fn following_phase(&self) -> &str {
        r"\s*(?:\-|\–|\~|\〜|a|fino\s*a|alle?|\?)\s*"
    }

    fn primary_prefix(&self) -> &str {
        r"(?:(?:alle?|dalle?)\s*)??"
    }

    fn primary_suffix(&self) -> &str {
        r"(?:\s*(?:di\s*(?:sera|notte|mattina|pomeriggio)))?(?!/)(?=\W|$)"
    }

    fn extract_primary_time_components(&self, context: &ParsingContext, m: &RegexMatch) -> Option<ParsingComponents> {
        let mut components = time_expression::extract_primary_time_components(self.strict_mode, context, m)?;
        let text = m.text();

        if js_regex!(r"di\s*(?:sera|notte)", "i").is_match(text) {
            let hour = components.get_or_zero(Component::Hour);
            if (6..12).contains(&hour) {
                components.assign(Component::Hour, hour + 12);
                components.assign(Component::Meridiem, meridiem::PM);
            } else if hour < 6 {
                components.assign(Component::Meridiem, meridiem::AM);
            }
        }

        if js_regex!(r"di\s*pomeriggio", "i").is_match(text) {
            components.assign(Component::Meridiem, meridiem::PM);
            let hour = components.get_or_zero(Component::Hour);
            if (0..=6).contains(&hour) {
                components.assign(Component::Hour, hour + 12);
            }
        }

        if js_regex!(r"di\s*mattina", "i").is_match(text) {
            components.assign(Component::Meridiem, meridiem::AM);
            let hour = components.get_or_zero(Component::Hour);
            if hour < 12 {
                components.assign(Component::Hour, hour);
            }
        }

        components.add_tag("parser/ITTimeExpressionParser");
        Some(components)
    }

    fn extract_following_time_components(
        &self,
        context: &ParsingContext,
        m: &RegexMatch,
        result: &mut ParsingResult,
    ) -> Option<ParsingComponents> {
        let mut following = time_expression::extract_following_time_components(context, m, result)?;
        following.add_tag("parser/ITTimeExpressionParser");
        Some(following)
    }
}