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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
//! A crate for generating plural rule operands from numberical input.
//!
//! This crate generates plural operands according to the specifications outlined at [Unicode's website](https://unicode.org/reports/tr35/tr35-numbers.html#Operands).
//!
//! Input is supported for int, float, and &str.
//!
//! # Examples
//!
//! Plural rules example for Polish
//!
//! ```
//! use intl_pluralrules::{PluralRules, PluralRuleType, PluralCategory};
//! use unic_langid::LanguageIdentifier;
//!
//! let langid: LanguageIdentifier = "pl".parse().expect("Parsing failed.");
//!
//! assert!(PluralRules::get_locales(PluralRuleType::CARDINAL).contains(&langid));
//!
//! let pr = PluralRules::create(langid.clone(), PluralRuleType::CARDINAL).unwrap();
//! assert_eq!(pr.select(1), Ok(PluralCategory::ONE));
//! assert_eq!(pr.select("3"), Ok(PluralCategory::FEW));
//! assert_eq!(pr.select(12), Ok(PluralCategory::MANY));
//! assert_eq!(pr.select("5.0"), Ok(PluralCategory::OTHER));
//!
//! assert_eq!(pr.get_locale(), &langid);
//! ```
/// A public AST module for plural rule representations.
pub mod operands;
#[cfg(not(tarpaulin_include))]
mod rules;
use std::convert::TryInto;
use unic_langid::LanguageIdentifier;
use crate::operands::PluralOperands;
use crate::rules::*;
/// A public enum for handling the plural category.
/// Each plural category will vary, depending on the language that is being used and whether that language has that plural category.
#[derive(Debug, Eq, PartialEq)]
pub enum PluralCategory {
ZERO,
ONE,
TWO,
FEW,
MANY,
OTHER,
}
/// A public enum for handling plural type.
#[derive(Copy, Clone, Hash, PartialEq, Eq)]
pub enum PluralRuleType {
/// Ordinal numbers express position or rank in a sequence. [More about oridinal numbers](https://en.wikipedia.org/wiki/Ordinal_number_(linguistics))
ORDINAL,
/// Cardinal numbers are natural numbers. [More about cardinal numbers](https://en.wikipedia.org/wiki/Cardinal_number)
CARDINAL,
}
// pub use rules::PluralRuleType;
/// CLDR_VERSION is the version of CLDR extracted from the file used to generate rules.rs.
pub use crate::rules::CLDR_VERSION;
/// The main structure for selecting plural rules.
///
/// # Examples
///
/// ```
/// use intl_pluralrules::{PluralRules, PluralRuleType, PluralCategory};
/// use unic_langid::LanguageIdentifier;
///
/// let langid: LanguageIdentifier = "naq".parse().expect("Parsing failed.");
/// let pr_naq = PluralRules::create(langid, PluralRuleType::CARDINAL).unwrap();
/// assert_eq!(pr_naq.select(1), Ok(PluralCategory::ONE));
/// assert_eq!(pr_naq.select("2"), Ok(PluralCategory::TWO));
/// assert_eq!(pr_naq.select(5.0), Ok(PluralCategory::OTHER));
/// ```
#[derive(Clone)]
pub struct PluralRules {
locale: LanguageIdentifier,
function: PluralRule,
}
impl PluralRules {
/// Returns an instance of PluralRules.
///
/// # Examples
/// ```
/// use intl_pluralrules::{PluralRules, PluralRuleType, PluralCategory};
/// use unic_langid::LanguageIdentifier;
///
/// let langid: LanguageIdentifier = "naq".parse().expect("Parsing failed.");
/// let pr_naq = PluralRules::create(langid, PluralRuleType::CARDINAL);
/// assert_eq!(pr_naq.is_ok(), !pr_naq.is_err());
///
/// let langid: LanguageIdentifier = "xx".parse().expect("Parsing failed.");
/// let pr_broken = PluralRules::create(langid, PluralRuleType::CARDINAL);
/// assert_eq!(pr_broken.is_err(), !pr_broken.is_ok());
/// ```
pub fn create<L: Into<LanguageIdentifier>>(
langid: L,
prt: PluralRuleType,
) -> Result<Self, &'static str> {
let langid = langid.into();
let returned_rule = match prt {
PluralRuleType::CARDINAL => {
let idx = rules::PRS_CARDINAL.binary_search_by_key(&&langid, |(l, _)| l);
idx.map(|idx| rules::PRS_CARDINAL[idx].1)
}
PluralRuleType::ORDINAL => {
let idx = rules::PRS_ORDINAL.binary_search_by_key(&&langid, |(l, _)| l);
idx.map(|idx| rules::PRS_ORDINAL[idx].1)
}
};
match returned_rule {
Ok(returned_rule) => Ok(Self {
locale: langid,
function: returned_rule,
}),
Err(_) => Err("unknown locale"),
}
}
/// Returns a result of the plural category for the given input.
///
/// If the input is not numeric.
///
/// # Examples
/// ```
/// use intl_pluralrules::{PluralRules, PluralRuleType, PluralCategory};
/// use unic_langid::LanguageIdentifier;
///
/// let langid: LanguageIdentifier = "naq".parse().expect("Parsing failed.");
/// let pr_naq = PluralRules::create(langid, PluralRuleType::CARDINAL).unwrap();
/// assert_eq!(pr_naq.select(1), Ok(PluralCategory::ONE));
/// assert_eq!(pr_naq.select(2), Ok(PluralCategory::TWO));
/// assert_eq!(pr_naq.select(5), Ok(PluralCategory::OTHER));
/// ```
pub fn select<N: TryInto<PluralOperands>>(
&self,
number: N,
) -> Result<PluralCategory, &'static str> {
let ops = number.try_into();
let pr = self.function;
match ops {
Ok(ops) => Ok(pr(&ops)),
Err(_) => Err("Argument can not be parsed to operands."),
}
}
/// Returns a list of the available locales.
///
/// # Examples
/// ```
/// use intl_pluralrules::{PluralRules, PluralRuleType};
///
/// assert_eq!(
/// PluralRules::get_locales(PluralRuleType::CARDINAL).is_empty(),
/// false
/// );
/// ```
pub fn get_locales(prt: PluralRuleType) -> Vec<LanguageIdentifier> {
let prs = match prt {
PluralRuleType::CARDINAL => rules::PRS_CARDINAL,
PluralRuleType::ORDINAL => rules::PRS_ORDINAL,
};
prs.iter().map(|(l, _)| l.clone()).collect()
}
/// Returns the locale name for this PluralRule instance.
///
/// # Examples
/// ```
/// use intl_pluralrules::{PluralRules, PluralRuleType};
/// use unic_langid::LanguageIdentifier;
///
/// let langid: LanguageIdentifier = "naq".parse().expect("Parsing failed.");
/// let pr_naq = PluralRules::create(langid.clone(), PluralRuleType::CARDINAL).unwrap();
/// assert_eq!(pr_naq.get_locale(), &langid);
/// ```
pub fn get_locale(&self) -> &LanguageIdentifier {
&self.locale
}
}
#[cfg(test)]
mod tests {
use super::{PluralCategory, PluralRuleType, PluralRules, CLDR_VERSION};
use unic_langid::LanguageIdentifier;
#[test]
fn cardinals_test() {
let langid: LanguageIdentifier = "naq".parse().expect("Parsing failed.");
let pr_naq = PluralRules::create(langid, PluralRuleType::CARDINAL).unwrap();
assert_eq!(pr_naq.select(1), Ok(PluralCategory::ONE));
assert_eq!(pr_naq.select(2), Ok(PluralCategory::TWO));
assert_eq!(pr_naq.select(5), Ok(PluralCategory::OTHER));
let langid: LanguageIdentifier = "xx".parse().expect("Parsing failed.");
let pr_broken = PluralRules::create(langid, PluralRuleType::CARDINAL);
assert_eq!(pr_broken.is_err(), !pr_broken.is_ok());
}
#[test]
fn ordinals_rules() {
let langid: LanguageIdentifier = "uk".parse().expect("Parsing failed.");
let pr_naq = PluralRules::create(langid, PluralRuleType::ORDINAL).unwrap();
assert_eq!(pr_naq.select(33), Ok(PluralCategory::FEW));
assert_eq!(pr_naq.select(113), Ok(PluralCategory::OTHER));
}
#[test]
fn version_test() {
assert_eq!(CLDR_VERSION, 37);
}
#[test]
fn locale_test() {
assert_eq!(
PluralRules::get_locales(PluralRuleType::CARDINAL).is_empty(),
false
);
}
}
|
