Rename icu-pluralrules -> icu-plurals and icu-unicodeset -> icu-uniset (

#323)

CODEOWNERS

@@ -8,6 +8,6 @@
 # List of components with at least two owners as specified in docs/crate-ownership.
 
 components/locale/               @zbraniecki @nciric
-components/pluralrules           @zbraniecki @sffc
+components/plurals/              @zbraniecki @sffc
 components/data-provider/        @sffc
 components/data-provider-json/   @sffc

Cargo.toml

@@ -9,7 +9,7 @@ members = [
     "components/uniset",
     "components/locale",
     "components/locale/macros",
-    "components/pluralrules",
+    "components/plurals",
     "components/datetime",
     "resources/testdata",
     "utils/fixed-decimal",

components/cldr-json-data-provider/Cargo.toml

@@ -17,7 +17,7 @@ include = [
 [dependencies]
 icu-data-provider = { path = "../data-provider" }
 icu-locale = { path = "../locale" }
-icu-pluralrules = { path = "../pluralrules" }
+icu-plurals = { path = "../plurals" }
 json = "0.12"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

components/cldr-json-data-provider/src/transform/plurals.rs

@@ -5,7 +5,7 @@ use crate::CldrPaths;
 use icu_data_provider::iter::DataEntryCollection;
 use icu_data_provider::prelude::*;
 use icu_data_provider::structs::plurals::*;
-use icu_pluralrules::rules::{parse, serialize};
+use icu_plurals::rules::{parse, serialize};
 use std::borrow::Cow;
 use std::convert::TryFrom;
 use std::marker::PhantomData;

components/icu/Cargo.toml

@@ -17,8 +17,8 @@ include = [
 [dependencies]
 icu-datetime = { path = "../datetime" }
 icu-locale = { path = "../locale" }
-icu-pluralrules = { path = "../pluralrules" }
-icu-unicodeset = { path = "../uniset" }
+icu-plurals = { path = "../plurals" }
+icu-uniset = { path = "../uniset" }
 
 [dev-dependencies]
 icu-testdata = { path = "../../resources/testdata" }

components/icu/src/lib.rs

@@ -62,6 +62,6 @@ pub use icu_datetime as datetime;
 #[doc(inline)]
 pub use icu_locale as locale;
 #[doc(inline)]
-pub use icu_pluralrules as plurals;
+pub use icu_plurals as plurals;
 #[doc(inline)]
-pub use icu_unicodeset as uniset;
+pub use icu_uniset as uniset;

components/pluralrules/Cargo.toml → components/plurals/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "icu-pluralrules"
+name = "icu-plurals"
 description = "Unicode Plural Rules categorizer for numeric input."
 version = "0.0.1"
 authors = ["The ICU4X Project Developers"]

components/pluralrules/benches/fixtures/mod.rs → components/plurals/benches/fixtures/mod.rs

@@ -1,5 +1,5 @@
 use icu_locale::LanguageIdentifier;
-use icu_pluralrules::PluralCategory;
+use icu_plurals::PluralCategory;
 
 use serde::Deserialize;
 

components/pluralrules/benches/operands.rs → components/plurals/benches/operands.rs

@@ -3,7 +3,7 @@ mod helpers;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use fixed_decimal::FixedDecimal;
-use icu_pluralrules::PluralOperands;
+use icu_plurals::PluralOperands;
 use std::convert::TryInto;
 
 fn operands(c: &mut Criterion) {

components/pluralrules/benches/parser.rs → components/plurals/benches/parser.rs

@@ -7,7 +7,7 @@ use icu_data_provider::{icu_data_key, structs, DataEntry, DataProvider, DataRequ
 use std::borrow::Cow;
 
 fn parser(c: &mut Criterion) {
-    use icu_pluralrules::rules::parse_condition;
+    use icu_plurals::rules::parse_condition;
 
     let plurals_data = helpers::get_plurals_data();
 
@@ -53,7 +53,7 @@ fn parser(c: &mut Criterion) {
 
     #[cfg(feature = "bench")]
     c.bench_function("parser/lex", |b| {
-        use icu_pluralrules::rules::Lexer;
+        use icu_plurals::rules::Lexer;
         b.iter(|| {
             for rule in &rules {
                 let _ = Lexer::new(black_box(rule.as_bytes())).count();

components/pluralrules/benches/pluralrules.rs → components/plurals/benches/pluralrules.rs

@@ -3,7 +3,7 @@ mod helpers;
 
 use criterion::{criterion_group, criterion_main, Criterion};
 
-use icu_pluralrules::{PluralRuleType, PluralRules};
+use icu_plurals::{PluralRuleType, PluralRules};
 
 fn pluralrules(c: &mut Criterion) {
     let plurals_data = helpers::get_plurals_data();

components/pluralrules/examples/elevator_floors.rs → components/plurals/examples/elevator_floors.rs

@@ -1,7 +1,7 @@
-// An example application which uses icu_pluralrules to construct a correct
+// An example application which uses icu_plurals to construct a correct
 // sentence for English based on the numerical value in Ordinal category.
 use icu_locale::LanguageIdentifier;
-use icu_pluralrules::{PluralCategory, PluralRuleType, PluralRules};
+use icu_plurals::{PluralCategory, PluralRuleType, PluralRules};
 
 const VALUES: &[usize] = &[0, 2, 25, 1, 3, 2, 4, 10, 7, 0];
 

components/pluralrules/examples/unread_emails.rs → components/plurals/examples/unread_emails.rs

@@ -1,7 +1,7 @@
-// An example application which uses icu_pluralrules to construct a correct
+// An example application which uses icu_plurals to construct a correct
 // sentence for English based on the numerical value in Cardinal category.
 use icu_locale::LanguageIdentifier;
-use icu_pluralrules::{PluralCategory, PluralRuleType, PluralRules};
+use icu_plurals::{PluralCategory, PluralRuleType, PluralRules};
 
 const VALUES: &[usize] = &[0, 2, 25, 1, 3, 2, 4, 10, 7, 0];
 

components/pluralrules/src/data.rs → components/plurals/src/data.rs

@@ -4,8 +4,8 @@
 //!
 //! ```
 //! use icu_locale::LanguageIdentifier;
-//! use icu_pluralrules::{PluralCategory, PluralRuleType, PluralOperands};
-//! use icu_pluralrules::data::{PluralRuleList, RulesSelector};
+//! use icu_plurals::{PluralCategory, PluralRuleType, PluralOperands};
+//! use icu_plurals::data::{PluralRuleList, RulesSelector};
 //! use icu_data_provider::prelude::*;
 //! use icu_data_provider::{InvariantDataProvider, structs};
 //! use std::borrow::Cow;

components/pluralrules/src/lib.rs → components/plurals/src/lib.rs

@@ -1,4 +1,4 @@
-//! `icu-pluralrules` is one of the [`ICU4X`] components.
+//! `icu-plurals` is one of the [`ICU4X`] components.
 //!
 //! This API provides functionality to determine the plural category
 //! appropriate for a given number in a given language.
@@ -21,7 +21,7 @@
 //!
 //! ```
 //! use icu_locale::LanguageIdentifier;
-//! use icu_pluralrules::{PluralRules, PluralRuleType, PluralCategory};
+//! use icu_plurals::{PluralRules, PluralRuleType, PluralCategory};
 //! use icu_data_provider::InvariantDataProvider;
 //!
 //! let lang: LanguageIdentifier = "en".parse()
@@ -131,7 +131,7 @@ pub enum PluralRuleType {
 ///
 /// ```
 /// use icu_locale::LanguageIdentifier;
-/// use icu_pluralrules::{PluralRules, PluralRuleType, PluralCategory};
+/// use icu_plurals::{PluralRules, PluralRuleType, PluralCategory};
 /// use icu_data_provider::InvariantDataProvider;
 ///
 /// let lang: LanguageIdentifier = "en".parse()
@@ -207,7 +207,7 @@ impl PluralCategory {
     /// # Examples
     ///
     /// ```
-    /// use icu_pluralrules::PluralCategory;
+    /// use icu_plurals::PluralCategory;
     ///
     /// let mut categories = PluralCategory::all();
     ///
@@ -239,7 +239,7 @@ impl PluralCategory {
 ///
 /// ```
 /// use icu_locale::LanguageIdentifier;
-/// use icu_pluralrules::{PluralRules, PluralRuleType, PluralCategory};
+/// use icu_plurals::{PluralRules, PluralRuleType, PluralCategory};
 /// use icu_data_provider::InvariantDataProvider;
 ///
 /// let lang: LanguageIdentifier = "en".parse()
@@ -271,7 +271,7 @@ impl PluralRules {
     ///
     /// ```
     /// use icu_locale::LanguageIdentifier;
-    /// use icu_pluralrules::{PluralRules, PluralRuleType};
+    /// use icu_plurals::{PluralRules, PluralRuleType};
     /// use icu_data_provider::InvariantDataProvider;
     ///
     /// let lang: LanguageIdentifier = "en".parse()
@@ -316,7 +316,7 @@ impl PluralRules {
     ///
     /// ```
     /// use icu_locale::LanguageIdentifier;
-    /// use icu_pluralrules::{PluralRules, PluralRuleType, PluralCategory};
+    /// use icu_plurals::{PluralRules, PluralRuleType, PluralCategory};
     /// use icu_data_provider::InvariantDataProvider;
     ///
     /// let lang: LanguageIdentifier = "en".parse()
@@ -346,8 +346,8 @@ impl PluralRules {
     /// ```
     /// # use std::convert::TryFrom;
     /// # use icu_locale::LanguageIdentifier;
-    /// # use icu_pluralrules::{PluralRules, PluralRuleType};
-    /// use icu_pluralrules::{PluralCategory, PluralOperands};
+    /// # use icu_plurals::{PluralRules, PluralRuleType};
+    /// use icu_plurals::{PluralCategory, PluralOperands};
     /// # use icu_data_provider::InvariantDataProvider;
     /// #
     /// # let lang: LanguageIdentifier = "en".parse()

components/pluralrules/src/operands.rs → components/plurals/src/operands.rs

@@ -15,7 +15,7 @@ use std::str::FromStr;
 /// From int
 ///
 /// ```
-/// use icu_pluralrules::PluralOperands;
+/// use icu_plurals::PluralOperands;
 /// assert_eq!(PluralOperands {
 ///    i: 2,
 ///    v: 0,
@@ -29,7 +29,7 @@ use std::str::FromStr;
 ///
 /// ```
 /// use std::str::FromStr;
-/// use icu_pluralrules::PluralOperands;
+/// use icu_plurals::PluralOperands;
 /// assert_eq!(Ok(PluralOperands {
 ///    i: 1234,
 ///    v: 3,
@@ -43,7 +43,7 @@ use std::str::FromStr;
 ///
 /// ```
 /// use std::convert::TryFrom;
-/// use icu_pluralrules::PluralOperands;
+/// use icu_plurals::PluralOperands;
 /// assert_eq!(Ok(PluralOperands {
 ///    i: 123,
 ///    v: 2,

components/pluralrules/src/rules/ast.rs → components/plurals/src/rules/ast.rs

@@ -5,8 +5,8 @@
 //! # Examples
 //!
 //! ```
-//! use icu_pluralrules::rules::parse_condition;
-//! use icu_pluralrules::rules::ast::*;
+//! use icu_plurals::rules::parse_condition;
+//! use icu_plurals::rules::ast::*;
 //!
 //! let input = "i = 1";
 //!
@@ -42,8 +42,8 @@ use std::ops::RangeInclusive;
 /// # Examples
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
-/// use icu_pluralrules::rules::{parse, parse_condition};
+/// use icu_plurals::rules::ast::*;
+/// use icu_plurals::rules::{parse, parse_condition};
 ///
 /// let condition = parse_condition(b"i = 5 or v = 2")
 ///     .expect("Parsing failed.");
@@ -87,8 +87,8 @@ pub struct Rule {
 /// # Examples
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
-/// use icu_pluralrules::rules::parse_condition;
+/// use icu_plurals::rules::ast::*;
+/// use icu_plurals::rules::parse_condition;
 ///
 /// let condition = Condition(Box::new([
 ///     AndCondition(Box::new([Relation {
@@ -131,7 +131,7 @@ pub struct Condition(pub Box<[AndCondition]>);
 /// Can be represented by the AST:
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 ///
 /// AndCondition(Box::new([
 ///     Relation {
@@ -169,7 +169,7 @@ pub struct AndCondition(pub Box<[Relation]>);
 /// Can be represented by the AST:
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 ///
 /// Relation {
 ///     expression: Expression {
@@ -216,7 +216,7 @@ pub enum Operator {
 /// Can be represented by the AST:
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 ///
 /// Expression {
 ///     operand: Operand::I,
@@ -243,7 +243,7 @@ pub struct Expression {
 /// Can be represented by the AST:
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::Operand;
+/// use icu_plurals::rules::ast::Operand;
 ///
 /// Operand::I;
 /// ```
@@ -276,7 +276,7 @@ pub enum Operand {
 /// Can be represented by the AST:
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 ///
 /// RangeList(Box::new([
 ///     RangeListItem::Value(Value(5)),
@@ -302,7 +302,7 @@ pub struct RangeList(pub Box<[RangeListItem]>);
 /// Can be represented by the AST:
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 ///
 /// let _ = RangeListItem::Value(Value(5));
 /// let _ = RangeListItem::Range(Value(11)..=Value(15));
@@ -326,7 +326,7 @@ pub enum RangeListItem {
 /// Can be represented by the AST:
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 ///
 /// RangeListItem::Value(Value(99));
 /// ```
@@ -342,7 +342,7 @@ pub struct Value(pub u64);
 /// ```
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 /// Samples {
 ///     integer: Some(SampleList {
 ///         sample_ranges: Box::new([SampleRange {
@@ -375,7 +375,7 @@ pub struct Samples {
 /// ```
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 /// SampleList {
 ///     sample_ranges: Box::new([
 ///         SampleRange {
@@ -401,7 +401,7 @@ pub struct SampleList {
 /// ```
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 /// SampleRange {
 ///     lower_val: DecimalValue("0.0".to_string()),
 ///     upper_val: Some(DecimalValue("1.5".to_string())),
@@ -422,7 +422,7 @@ pub struct SampleRange {
 /// ```
 ///
 /// ```
-/// use icu_pluralrules::rules::ast::*;
+/// use icu_plurals::rules::ast::*;
 /// DecimalValue("1.00".to_string());
 /// ```
 #[derive(Debug, Clone, PartialEq)]

components/pluralrules/src/rules/lexer.rs → components/plurals/src/rules/lexer.rs

@@ -32,7 +32,7 @@ pub enum LexerError {
 /// # Examples
 ///
 /// ```
-/// use icu_pluralrules::rules::Lexer;
+/// use icu_plurals::rules::Lexer;
 ///
 /// let input = b"i = 5";
 /// let lexer = Lexer::new(input);
@@ -49,7 +49,7 @@ impl<'l> Lexer<'l> {
     /// # Examples
     ///
     /// ```
-    /// use icu_pluralrules::rules::Lexer;
+    /// use icu_plurals::rules::Lexer;
     ///
     /// Lexer::new(b"n = 1");
     /// ```