Add JSON data provider with sample number data

Cargo.toml

@@ -1,6 +1,8 @@
 [workspace]
 
 members = [
+    "components/data-provider",
+    "components/data-provider-json",
     "components/icu",
     "components/icu4x",
     "components/locale",

components/data-provider-json/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "icu-data-provider-json"
+description = "ICU4X data provider that reads from JSON files"
+version = "0.0.1"
+authors = ["The ICU4X Project Developers"]
+edition = "2018"
+readme = "README.md"
+repository = "https://github.com/unicode-org/icu4x"
+license = "MIT/Apache-2.0"
+categories = ["internationalization"]
+include = [
+    "src/**/*",
+    "Cargo.toml",
+    "README.md"
+]
+
+[features]
+default = ["std"]
+std = ["no-std-compat/std", "serde/std", "serde_json/std"]
+
+[dependencies]
+icu-data-provider = { path = "../data-provider" }
+icu-locale = { path = "../locale" }
+
+[dependencies.async-trait]
+version = "0.1.30"
+
+[dependencies.serde]
+version = "1.0"
+default-features = false
+features = ["derive", "alloc"]
+
+[dependencies.serde_json]
+version = "1.0"
+default-features = false
+features = ["alloc"]
+
+[dependencies.no-std-compat]
+version = "0.4.0"
+features = ["alloc"]
+
+[[test]]
+name = "file_io"
+path = "tests/test_file_io.rs"
+required-features = ["std"]

components/data-provider-json/README.md

@@ -0,0 +1,11 @@
+# ICU4X
+
+ICU4X is a set of internationalization components for Unicode.
+
+# Status [![crates.io](http://meritbadge.herokuapp.com/icu-util)](https://crates.io/crates/icu-util)
+
+The project is in an incubation period.
+
+# Authors
+
+The project is managed by a subcommittee of ICU-TC in the Unicode Consortium focused on providing solutions for client-side internationalization.

components/data-provider-json/src/lib.rs

@@ -0,0 +1,79 @@
+#![no_std]
+
+extern crate no_std_compat as std;
+
+use std::prelude::v1::*;
+
+use icu_data_provider::DataProvider;
+use icu_data_provider::Request;
+use icu_data_provider::Response;
+use icu_data_provider::ResponseBuilder;
+use icu_data_provider::ResponseError;
+use icu_locale::LanguageIdentifier;
+
+mod schema;
+
+#[cfg(feature = "std")]
+use std::io::Read;
+
+#[derive(Debug)]
+pub enum Error {
+    JsonError(serde_json::error::Error),
+}
+
+impl From<serde_json::error::Error> for Error {
+    fn from(err: serde_json::error::Error) -> Error {
+        Error::JsonError(err)
+    }
+}
+
+/// A data provider reading from a JSON file.
+#[derive(Debug)]
+pub struct JsonDataProvider {
+    data: schema::JsonSchema,
+}
+
+impl JsonDataProvider {
+    /// Create a JsonDataProvider from a file reader.
+    #[cfg(feature = "std")]
+    pub fn from_reader<R: Read>(reader: R) -> Result<Self, Error> {
+        let result: schema::JsonSchema = serde_json::from_reader(reader)?;
+        Ok(JsonDataProvider { data: result })
+    }
+
+    /// Create a JsonDataProvider from a JSON string slice.
+    pub fn from_str(data: &str) -> Result<Self, Error> {
+        let result: schema::JsonSchema = serde_json::from_str(data)?;
+        Ok(JsonDataProvider { data: result })
+    }
+
+    /// Create a JsonDataProvider from a &[u8] slice.
+    pub fn from_slice(data: &[u8]) -> Result<Self, Error> {
+        let result: schema::JsonSchema = serde_json::from_slice(data)?;
+        Ok(JsonDataProvider { data: result })
+    }
+}
+
+impl<'a> DataProvider<'a, 'a> for JsonDataProvider {
+    /// Loads JSON data. Returns borrowed data.
+    fn load(&'a self, _request: &Request) -> Result<Response<'a>, ResponseError> {
+        let response = ResponseBuilder {
+            data_langid: LanguageIdentifier::default(),
+        }
+        .with_borrowed_payload(&self.data.decimal.symbols_v1_a);
+        Ok(response)
+    }
+}
+
+#[test]
+fn test_empty_str() {
+    let result = JsonDataProvider::from_str("");
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    // Coverage for Debug trait:
+    println!("{:?}", err);
+    // An unconditional let is possible here because it is a one-element enum.
+    // If more cases are needed, see https://github.com/rust-lang/rfcs/pull/1303
+    let Error::JsonError(json_err) = err;
+    assert_eq!(json_err.classify(), serde_json::error::Category::Eof);
+}

components/data-provider-json/src/schema.rs

@@ -0,0 +1,15 @@
+use icu_data_provider as datap;
+use serde::{Deserialize, Serialize};
+
+#[allow(unused_imports)]
+use std::prelude::v1::*;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub(crate) struct DecimalJsonSchema {
+    pub(crate) symbols_v1_a: datap::decimal::SymbolsV1,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub(crate) struct JsonSchema {
+    pub(crate) decimal: DecimalJsonSchema,
+}

components/data-provider-json/tests/test_file_io.rs

@@ -0,0 +1,35 @@
+use icu_data_provider_json;
+
+use std::borrow::Cow;
+
+use std::fs::File;
+use std::io::BufReader;
+
+use icu_data_provider as datap;
+use icu_data_provider::DataProvider;
+use icu_data_provider_json::JsonDataProvider;
+
+#[test]
+fn test_read_json() {
+    let file = File::open("tests/testdata/all.json").unwrap();
+    let reader = BufReader::new(file);
+    let json_data_provider = JsonDataProvider::from_reader(reader).unwrap();
+    println!("{:?}", json_data_provider); // Coverage for Debug trait
+    let response = json_data_provider
+        .load(&datap::Request {
+            langid: "en-US".parse().unwrap(),
+            category: datap::Category::Decimal,
+            key: datap::decimal::Key::SymbolsV1.into(),
+            payload: None,
+        })
+        .unwrap();
+    let decimal_data: &datap::decimal::SymbolsV1 = response.borrow_payload().unwrap();
+    assert_eq!(
+        decimal_data,
+        &datap::decimal::SymbolsV1 {
+            zero_digit: '0',
+            decimal_separator: Cow::Borrowed("."),
+            grouping_separator: Cow::Borrowed(","),
+        }
+    );
+}

components/data-provider-json/tests/test_no_std.rs

@@ -0,0 +1,87 @@
+extern crate icu_data_provider_json;
+
+use std::borrow::Cow;
+use std::prelude::v1::*;
+
+use icu_data_provider as datap;
+use icu_data_provider::DataProvider;
+use icu_data_provider_json::JsonDataProvider;
+
+const DATA: &'static str = r#"{
+    "decimal": {
+        "symbols_v1_a": {
+            "zero_digit": "0",
+            "decimal_separator": ".",
+            "grouping_separator": ","
+        }
+    }
+}"#;
+
+fn get_provider() -> JsonDataProvider {
+    JsonDataProvider::from_str(DATA).unwrap()
+}
+
+fn get_response(provider: &JsonDataProvider) -> datap::Response {
+    return provider
+        .load(&datap::Request {
+            langid: "en-US".parse().unwrap(),
+            category: datap::Category::Decimal,
+            key: datap::decimal::Key::SymbolsV1.into(),
+            payload: None,
+        })
+        .unwrap();
+}
+
+fn check_data(decimal_data: &datap::decimal::SymbolsV1) {
+    assert_eq!(
+        decimal_data,
+        &datap::decimal::SymbolsV1 {
+            zero_digit: '0',
+            decimal_separator: Cow::Borrowed("."),
+            grouping_separator: Cow::Borrowed(","),
+        }
+    );
+}
+
+#[test]
+fn test_read_string() {
+    let provider = get_provider();
+    let response = get_response(&provider);
+    let decimal_data: &datap::decimal::SymbolsV1 = response.borrow_payload().unwrap();
+    check_data(decimal_data);
+}
+
+#[test]
+fn test_read_utf8() {
+    let provider = JsonDataProvider::from_slice(DATA.as_bytes()).unwrap();
+    let response = get_response(&provider);
+    let decimal_data: &datap::decimal::SymbolsV1 = response.borrow_payload().unwrap();
+    check_data(decimal_data);
+}
+
+#[test]
+fn test_borrow_payload_mut() {
+    let provider = get_provider();
+    let mut response = get_response(&provider);
+    let decimal_data: &mut datap::decimal::SymbolsV1 = response.borrow_payload_mut().unwrap();
+    check_data(decimal_data);
+}
+
+#[test]
+fn test_take_payload() {
+    let provider = get_provider();
+    let response = get_response(&provider);
+    let decimal_data: Cow<datap::decimal::SymbolsV1> = response.take_payload().unwrap();
+    check_data(&decimal_data);
+}
+
+#[test]
+fn test_clone_payload() {
+    let final_data = {
+        let provider = get_provider();
+        let response = get_response(&provider);
+        let decimal_data: Cow<datap::decimal::SymbolsV1> = response.take_payload().unwrap();
+        decimal_data.into_owned()
+    };
+    check_data(&final_data);
+}

components/data-provider-json/tests/testdata/all.json

@@ -0,0 +1,9 @@
+{
+    "decimal": {
+        "symbols_v1_a": {
+            "zero_digit": "0",
+            "decimal_separator": ".",
+            "grouping_separator": ","
+        }
+    }
+}

components/data-provider/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "icu-data-provider"
+description = "Trait and struct definitions for the ICU data provider"
+version = "0.0.1"
+authors = ["The ICU4X Project Developers"]
+edition = "2018"
+readme = "README.md"
+repository = "https://github.com/unicode-org/icu4x"
+license = "MIT/Apache-2.0"
+categories = ["internationalization"]
+include = [
+    "src/**/*",
+    "Cargo.toml",
+    "README.md"
+]
+
+[features]
+default = ["std"]
+std = ["serde/std", "no-std-compat/std"]
+
+[dependencies]
+icu-locale = { path = "../locale" }
+
+[dependencies.downcast-rs]
+version = "1.1.1"
+
+[dependencies.async-trait]
+version = "0.1.30"
+
+[dependencies.serde]
+version = "1.0"
+default-features = false
+features = ["derive", "alloc"]
+
+[dependencies.no-std-compat]
+version = "0.4.0"
+features = ["alloc"]

components/data-provider/README.md

@@ -0,0 +1,11 @@
+# ICU4X
+
+ICU4X is a set of internationalization components for Unicode.
+
+# Status [![crates.io](http://meritbadge.herokuapp.com/icu-util)](https://crates.io/crates/icu-util)
+
+The project is in an incubation period.
+
+# Authors
+
+The project is managed by a subcommittee of ICU-TC in the Unicode Consortium focused on providing solutions for client-side internationalization.

components/data-provider/src/decimal.rs

@@ -0,0 +1,28 @@
+// Decimal types
+
+use std::prelude::v1::*;
+
+use std::borrow::Cow;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(PartialEq, Copy, Clone, Debug)]
+pub enum Key {
+    SymbolsV1 = 1,
+}
+
+impl From<Key> for crate::Key {
+    fn from(value: Key) -> Self {
+        crate::Key::Decimal(value)
+    }
+}
+
+// TODO: de-duplicate the name "SymbolsV1" between Key and the struct
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+pub struct SymbolsV1 {
+    pub zero_digit: char,
+    // String ownership discussion:
+    // https://github.com/unicode-org/icu4x/pull/61#discussion_r429051895
+    pub decimal_separator: Cow<'static, str>,
+    pub grouping_separator: Cow<'static, str>,
+}