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

//! upstream `ParsingResult`.

use super::components::ParsingComponents;
use super::js_date::JsDate;
use super::reference::ReferenceWithTimezone;

/// upstream `ParsingResult`. `index` is a **byte** offset into the parsed text; JSON output
/// converts it to UTF-16 units to match JavaScript.
#[derive(Clone, Debug, PartialEq)]
pub struct ParsingResult {
    pub reference: ReferenceWithTimezone,
    pub ref_date: JsDate,
    pub index: usize,
    pub text: String,
    pub start: ParsingComponents,
    pub end: Option<ParsingComponents>,
}

impl ParsingResult {
    /// upstream `clone()`: start and end are cloned the upstream way, without their tags
    /// ([`ParsingComponents::js_clone`]).
    pub fn js_clone(&self) -> ParsingResult {
        ParsingResult {
            reference: self.reference,
            ref_date: self.ref_date,
            index: self.index,
            text: self.text.clone(),
            start: self.start.js_clone(),
            end: self.end.as_ref().map(ParsingComponents::js_clone),
        }
    }

    /// `new ParsingResult(reference, index, text, start?, end?)`.
    pub fn new(
        reference: ReferenceWithTimezone,
        index: usize,
        text: impl Into<String>,
        start: Option<ParsingComponents>,
        end: Option<ParsingComponents>,
    ) -> ParsingResult {
        ParsingResult {
            reference,
            ref_date: reference.instant,
            index,
            text: text.into(),
            start: start.unwrap_or_else(|| ParsingComponents::new(reference, &[])),
            end,
        }
    }

    /// `date()`.
    pub fn date(&self) -> JsDate {
        self.start.date()
    }

    pub fn add_tag(&mut self, tag: &str) -> &mut Self {
        self.start.add_tag(tag);
        if let Some(end) = self.end.as_mut() {
            end.add_tag(tag);
        }
        self
    }

    pub fn add_tags<'a>(&mut self, tags: impl IntoIterator<Item = &'a str> + Clone) -> &mut Self {
        self.start.add_tags(tags.clone());
        if let Some(end) = self.end.as_mut() {
            end.add_tags(tags);
        }
        self
    }

    /// `tags()`: start's tags, then end's, without duplicates.
    pub fn tags(&self) -> Vec<String> {
        let mut tags: Vec<String> = self.start.tags().to_vec();
        if let Some(end) = &self.end {
            for t in end.tags() {
                if !tags.contains(t) {
                    tags.push(t.clone());
                }
            }
        }
        tags
    }
}