9457158389

Committed 10 Jun 2024 11:45PM UTC coverage: 75.174% (+0.05%) from 75.121%

Build # 9457158389

Build Type

push

github

Committed by

web-flow

Commit Message

Add constructing TinyAsciiStr from utf16 (#5025)

Introduces TinyAsciiStr constructors from utf16 and converges on the
consensus from #4931.

---------

Co-authored-by: Robert Bastian <4706271+robertbastian@users.noreply.github.com>

Run Details

65 of 82 new or added lines in 14 files covered. (79.27%)

3441 existing lines in 141 files now uncovered.

52850 of 70304 relevant lines covered (75.17%)

563298.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.61

/components/datetime/src/pattern/runtime/generic.rs

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

use super::{
    super::{reference, PatternError},
    super::{GenericPatternItem, PatternItem},
    Pattern,
};
use alloc::vec::Vec;
use core::str::FromStr;
use icu_provider::prelude::*;
use zerovec::ZeroVec;

#[derive(Debug, PartialEq, Eq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
#[allow(clippy::exhaustive_structs)] // this type is stable
#[cfg_attr(
    feature = "datagen",
    derive(databake::Bake),
    databake(path = icu_datetime::pattern::runtime),
)]
pub struct GenericPattern<'data> {
    pub items: ZeroVec<'data, GenericPatternItem>,
}

/// A ZeroSlice containing a 0, 1, and 2 placeholder
#[cfg(feature = "experimental")]
pub(crate) const ZERO_ONE_SLICE: &zerovec::ZeroSlice<GenericPatternItem> = zerovec::zeroslice!(
    GenericPatternItem;
    GenericPatternItem::to_unaligned_const;
    [
        GenericPatternItem::Placeholder(0),
        GenericPatternItem::Placeholder(1),
        GenericPatternItem::Placeholder(2),
    ]
);

impl<'data> GenericPattern<'data> {
    /// The function allows for creation of new DTF pattern from a generic pattern
    /// and replacement patterns.
    ///
    /// # Examples
    ///
    /// ```
    /// use icu::datetime::pattern::runtime::{GenericPattern, Pattern};
    ///
    /// let date: Pattern = "Y-m-d".parse().expect("Failed to parse pattern");
    /// let time: Pattern = "HH:mm".parse().expect("Failed to parse pattern");
    ///
    /// let glue: GenericPattern = "{1} 'at' {0}"
    ///     .parse()
    ///     .expect("Failed to parse generic pattern");
    /// assert_eq!(
    ///     glue.combined(date, time)
    ///         .expect("Failed to combine patterns")
    ///         .to_string(),
    ///     "Y-m-d 'at' HH:mm"
    /// );
    /// ```
    pub fn combined(
        self,
        date: Pattern<'data>,
        time: Pattern<'data>,
    ) -> Result<Pattern<'static>, PatternError> {
        let size = date.items.len() + time.items.len();
        let mut result = Vec::with_capacity(self.items.len() + size);

        for item in self.items.iter() {
            match item {
                GenericPatternItem::Placeholder(0) => {
                    result.extend(time.items.iter());
                }
                GenericPatternItem::Placeholder(1) => {
                    result.extend(date.items.iter());
                }
                GenericPatternItem::Placeholder(idx) => {
                    #[allow(clippy::unwrap_used)] // idx is a valid base-10 digit
                    return Err(PatternError::UnknownSubstitution(
                        char::from_digit(idx as u32, 10).unwrap(),
                    ));
                }
                GenericPatternItem::Literal(ch) => result.push(PatternItem::Literal(ch)),
            }
        }

        Ok(Pattern::from(result))
    }
}

impl Default for GenericPattern<'_> {
    fn default() -> Self {
        Self {
            items: ZeroVec::new(),
        }
    }
}

impl From<&reference::GenericPattern> for GenericPattern<'_> {
    fn from(input: &reference::GenericPattern) -> Self {
        Self {
            items: ZeroVec::alloc_from_slice(&input.items),
        }
    }
}

impl From<&GenericPattern<'_>> for reference::GenericPattern {
    fn from(input: &GenericPattern<'_>) -> Self {
        Self {
            items: input.items.to_vec(),
        }
    }
}

#[cfg(feature = "datagen")]
impl core::fmt::Display for GenericPattern<'_> {
    fn fmt(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
        let reference = reference::GenericPattern::from(self);
        reference.fmt(formatter)
    }
}

impl FromStr for GenericPattern<'_> {
    type Err = PatternError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let reference = reference::GenericPattern::from_str(s)?;
        Ok(Self::from(&reference))
    }
}

#[cfg(test)]
#[cfg(feature = "datagen")]
mod test {
    use super::*;

    #[test]
    fn test_runtime_generic_pattern_combine() {
        let pattern: GenericPattern = "{1} 'at' {0}"
            .parse()
            .expect("Failed to parse a generic pattern.");

        let date = "Y/m/d".parse().expect("Failed to parse a date pattern.");

        let time = "HH:mm".parse().expect("Failed to parse a time pattern.");

        let pattern = pattern
            .combined(date, time)
            .expect("Failed to combine date and time.");
        let pattern = reference::Pattern::from(pattern.items.to_vec());

        assert_eq!(pattern.to_string(), "Y/m/d 'at' HH:mm");
    }
}

1	// This file is part of ICU4X. For terms of use, please see the file
2	// called LICENSE at the top level of the ICU4X source tree
3	// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5	use super::{
6	super::{reference, PatternError},
7	super::{GenericPatternItem, PatternItem},
8	Pattern,
9	};
10	use alloc::vec::Vec;
11	use core::str::FromStr;
12	use icu_provider::prelude::*;
13	use zerovec::ZeroVec;
14
15	#[derive(Debug, PartialEq, Eq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]	7,934✔
16	#[allow(clippy::exhaustive_structs)] // this type is stable
17	#[cfg_attr(
18	feature = "datagen",
19	derive(databake::Bake),	×
20	databake(path = icu_datetime::pattern::runtime),
21	)]
22	pub struct GenericPattern<'data> {
23	pub items: ZeroVec<'data, GenericPatternItem>,	3,578✔
24	}
25
26	/// A ZeroSlice containing a 0, 1, and 2 placeholder
27	#[cfg(feature = "experimental")]
28	pub(crate) const ZERO_ONE_SLICE: &zerovec::ZeroSlice<GenericPatternItem> = zerovec::zeroslice!(
29	GenericPatternItem;
30	GenericPatternItem::to_unaligned_const;
31	[
32	GenericPatternItem::Placeholder(0),
33	GenericPatternItem::Placeholder(1),
34	GenericPatternItem::Placeholder(2),
35	]
36	);
37
38	impl<'data> GenericPattern<'data> {
39	/// The function allows for creation of new DTF pattern from a generic pattern
40	/// and replacement patterns.
41	///
42	/// # Examples
43	///
44	/// ```
45	/// use icu::datetime::pattern::runtime::{GenericPattern, Pattern};
46	///
47	/// let date: Pattern = "Y-m-d".parse().expect("Failed to parse pattern");
48	/// let time: Pattern = "HH:mm".parse().expect("Failed to parse pattern");
49	///
50	/// let glue: GenericPattern = "{1} 'at' {0}"
51	/// .parse()
52	/// .expect("Failed to parse generic pattern");
53	/// assert_eq!(
54	/// glue.combined(date, time)
55	/// .expect("Failed to combine patterns")
56	/// .to_string(),
57	/// "Y-m-d 'at' HH:mm"
58	/// );
59	/// ```
60	pub fn combined(	464✔
61	self,
62	date: Pattern<'data>,
63	time: Pattern<'data>,
64	) -> Result<Pattern<'static>, PatternError> {
65	let size = date.items.len() + time.items.len();	464✔
66	let mut result = Vec::with_capacity(self.items.len() + size);	464✔
67
68	for item in self.items.iter() {	1,486✔
69	match item {	1,022✔
70	GenericPatternItem::Placeholder(0) => {
71	result.extend(time.items.iter());	464✔
72	}
73	GenericPatternItem::Placeholder(1) => {
74	result.extend(date.items.iter());	207✔
75	}
UNCOV 76	GenericPatternItem::Placeholder(idx) => {	×
77	#[allow(clippy::unwrap_used)] // idx is a valid base-10 digit
78	return Err(PatternError::UnknownSubstitution(	×
UNCOV 79	char::from_digit(idx as u32, 10).unwrap(),	×
80	));
81	}
82	GenericPatternItem::Literal(ch) => result.push(PatternItem::Literal(ch)),	351✔
83	}
84	}
85
86	Ok(Pattern::from(result))	464✔
87	}	464✔
88	}
89
90	impl Default for GenericPattern<'_> {
91	fn default() -> Self {	×
92	Self {	×
UNCOV 93	items: ZeroVec::new(),	×
94	}
UNCOV 95	}	×
96	}
97
98	impl From<&reference::GenericPattern> for GenericPattern<'_> {
99	fn from(input: &reference::GenericPattern) -> Self {	33,814✔
100	Self {	33,814✔
101	items: ZeroVec::alloc_from_slice(&input.items),	33,814✔
102	}
103	}	33,814✔
104	}
105
106	impl From<&GenericPattern<'_>> for reference::GenericPattern {
107	fn from(input: &GenericPattern<'_>) -> Self {	1✔
108	Self {	1✔
109	items: input.items.to_vec(),	1✔
110	}
111	}	1✔
112	}
113
114	#[cfg(feature = "datagen")]
115	impl core::fmt::Display for GenericPattern<'_> {
116	fn fmt(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {	1✔
117	let reference = reference::GenericPattern::from(self);	1✔
118	reference.fmt(formatter)	1✔
119	}	1✔
120	}
121
122	impl FromStr for GenericPattern<'_> {
123	type Err = PatternError;
124
125	fn from_str(s: &str) -> Result<Self, Self::Err> {	33,805✔
126	let reference = reference::GenericPattern::from_str(s)?;	33,805✔
127	Ok(Self::from(&reference))	33,805✔
128	}	33,805✔
129	}
130
131	#[cfg(test)]
132	#[cfg(feature = "datagen")]
133	mod test {
134	use super::*;
135
136	#[test]
137	fn test_runtime_generic_pattern_combine() {	2✔
138	let pattern: GenericPattern = "{1} 'at' {0}"	1✔
139	.parse()
140	.expect("Failed to parse a generic pattern.");	1✔
141
142	let date = "Y/m/d".parse().expect("Failed to parse a date pattern.");	1✔
143
144	let time = "HH:mm".parse().expect("Failed to parse a time pattern.");	1✔
145
146	let pattern = pattern	2✔
147	.combined(date, time)	1✔
148	.expect("Failed to combine date and time.");
149	let pattern = reference::Pattern::from(pattern.items.to_vec());	1✔
150
151	assert_eq!(pattern.to_string(), "Y/m/d 'at' HH:mm");	1✔
152	}	2✔
153	}

zbraniecki / icu4x / 9457158389

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous