Merge pull request #48 from yassun7010/add_fluent_doc

Add fluent doc

Author: ya7010

axum_serde_valid/src/features/jsonschema.rs

@@ -1,61 +1,3 @@
-use std::{
-    any::{type_name, TypeId},
-    cell::RefCell,
-    collections::{HashMap, VecDeque},
-};
+mod context;
 
-use jsonschema::{
-    output::{BasicOutput, ErrorDescription, OutputUnit},
-    JSONSchema,
-};
-use schemars::gen::{SchemaGenerator, SchemaSettings};
-use serde_json::{Map, Value};
-
-thread_local! {
-    static CONTEXT: RefCell<SchemaContext> = RefCell::new(SchemaContext::new());
-}
-
-pub(crate) struct SchemaContext {
-    pub generator: SchemaGenerator,
-    pub schemas: HashMap<TypeId, JSONSchema>,
-}
-
-impl SchemaContext {
-    pub fn new() -> Self {
-        Self {
-            generator: SchemaSettings::draft07()
-                .with(|settings| settings.inline_subschemas = true)
-                .into_generator(),
-            schemas: HashMap::default(),
-        }
-    }
-
-    pub fn validate<T>(value: &Value) -> Result<(), VecDeque<OutputUnit<ErrorDescription>>>
-    where
-        T: crate::traits::validated::Deserialize + schemars::JsonSchema + 'static,
-    {
-        CONTEXT.with(|ctx| {
-            let ctx = &mut *ctx.borrow_mut();
-            let schema = ctx.schemas.entry(TypeId::of::<T>()).or_insert_with(|| {
-                match jsonschema::JSONSchema::compile(
-                    &serde_json::to_value(ctx.generator.root_schema_for::<T>()).unwrap(),
-                ) {
-                    Ok(s) => s,
-                    Err(error) => {
-                        tracing::error!(
-                            %error,
-                            type_name = type_name::<T>(),
-                            "invalid JSON schema for type"
-                        );
-                        JSONSchema::compile(&Value::Object(Map::default())).unwrap()
-                    }
-                }
-            });
-
-            match schema.apply(value).basic() {
-                BasicOutput::Valid(_) => Ok(()),
-                BasicOutput::Invalid(v) => Err(v),
-            }
-        })
-    }
-}
+pub(crate) use context::SchemaContext;

axum_serde_valid/src/features/jsonschema/context.rs

@@ -0,0 +1,61 @@
+use std::{
+    any::{type_name, TypeId},
+    cell::RefCell,
+    collections::{HashMap, VecDeque},
+};
+
+use jsonschema::{
+    output::{BasicOutput, ErrorDescription, OutputUnit},
+    JSONSchema,
+};
+use schemars::gen::{SchemaGenerator, SchemaSettings};
+use serde_json::{Map, Value};
+
+thread_local! {
+    static CONTEXT: RefCell<SchemaContext> = RefCell::new(SchemaContext::new());
+}
+
+pub(crate) struct SchemaContext {
+    pub generator: SchemaGenerator,
+    pub schemas: HashMap<TypeId, JSONSchema>,
+}
+
+impl SchemaContext {
+    pub fn new() -> Self {
+        Self {
+            generator: SchemaSettings::draft07()
+                .with(|settings| settings.inline_subschemas = true)
+                .into_generator(),
+            schemas: HashMap::default(),
+        }
+    }
+
+    pub fn validate<T>(value: &Value) -> Result<(), VecDeque<OutputUnit<ErrorDescription>>>
+    where
+        T: crate::traits::validated::Deserialize + schemars::JsonSchema + 'static,
+    {
+        CONTEXT.with(|ctx| {
+            let ctx = &mut *ctx.borrow_mut();
+            let schema = ctx.schemas.entry(TypeId::of::<T>()).or_insert_with(|| {
+                match jsonschema::JSONSchema::compile(
+                    &serde_json::to_value(ctx.generator.root_schema_for::<T>()).unwrap(),
+                ) {
+                    Ok(s) => s,
+                    Err(error) => {
+                        tracing::error!(
+                            %error,
+                            type_name = type_name::<T>(),
+                            "invalid JSON schema for type"
+                        );
+                        JSONSchema::compile(&Value::Object(Map::default())).unwrap()
+                    }
+                }
+            });
+
+            match schema.apply(value).basic() {
+                BasicOutput::Valid(_) => Ok(()),
+                BasicOutput::Invalid(v) => Err(v),
+            }
+        })
+    }
+}

serde_valid/README.md

@@ -158,6 +158,35 @@ assert_eq!(
 );
 ```
 
+### Fluent localization
+
+You can also use [fluent](https://projectfluent.org/) localization by using `fluent` feature.
+
+```rust
+use unic_langid::LanguageIdentifier;
+use serde_json::json;
+use serde_valid::{fluent::Localize, Validate};
+
+#
+
+#[derive(Validate)]
+struct Data (
+    #[validate(min_length = 3, fluent("name-min-length", min_length = 3))]
+    String,
+);
+
+assert_eq!(
+    Data("田中".to_string()).validate()
+        .unwrap_err()
+        .localize(&get_bundle("name-min-length = 名前の長さは { $min_length } 文字以上でないといけません。"))
+        .to_string(),
+    json!({
+        "errors": ["名前の長さは \u{2068}3\u{2069} 文字以上でないといけません。"]
+    })
+    .to_string()
+);
+```
+
 ## Custom method
 
 You can use your custom validation using by `#[validate(custom)]`.

serde_valid/src/lib.rs

@@ -158,6 +158,45 @@
 //! );
 //! ```
 //!
+//! ### Fluent localization
+//!
+//! You can also use [fluent](https://projectfluent.org/) localization by using `fluent` feature.
+//!
+//! ```rust
+//! # #[cfg(feature = "fluent")] {
+//! # use fluent::{FluentBundle, FluentResource};
+//! use unic_langid::LanguageIdentifier;
+//! use serde_json::json;
+//! use serde_valid::{fluent::Localize, Validate};
+//!
+//! # fn get_bundle(source: impl Into<String>) -> FluentBundle<FluentResource> {
+//! #     let res = FluentResource::try_new(source.into()).expect("Failed to parse an FTL string.");
+//! #     let langid_en: LanguageIdentifier = "ja_JP".parse().expect("Parsing failed");
+//! #     let mut bundle = FluentBundle::new(vec![langid_en]);
+//! #     bundle.add_resource(res).unwrap();
+//! #     bundle
+//! # }
+//! #
+//!
+//! #[derive(Validate)]
+//! struct Data (
+//!     #[validate(min_length = 3, fluent("name-min-length", min_length = 3))]
+//!     String,
+//! );
+//!
+//! assert_eq!(
+//!     Data("田中".to_string()).validate()
+//!         .unwrap_err()
+//!         .localize(&get_bundle("name-min-length = 名前の長さは { $min_length } 文字以上でないといけません。"))
+//!         .to_string(),
+//!     json!({
+//!         "errors": ["名前の長さは \u{2068}3\u{2069} 文字以上でないといけません。"]
+//!     })
+//!     .to_string()
+//! );
+//! # }
+//! ```
+//!
 //! ## Custom method
 //!
 //! You can use your custom validation using by `#[validate(custom)]`.

serde_valid/tests/fluent_test.rs

@@ -6,11 +6,8 @@ mod tests {
     use serde_valid::{fluent::Localize, Validate};
     use unic_langid::LanguageIdentifier;
 
-    fn get_bundle() -> FluentBundle<FluentResource> {
-        let ftl_string = ["hello-world = Hello, world!", "intro = Welcome, { $name }."]
-            .join("\n")
-            .to_string();
-        let res = FluentResource::try_new(ftl_string).expect("Failed to parse an FTL string.");
+    fn get_bundle(source: impl Into<String>) -> FluentBundle<FluentResource> {
+        let res = FluentResource::try_new(source.into()).expect("Failed to parse an FTL string.");
 
         let langid_en: LanguageIdentifier = "en-US".parse().expect("Parsing failed");
         let mut bundle = FluentBundle::new(vec![langid_en]);
@@ -30,7 +27,10 @@ mod tests {
         }
 
         let test = Test { a: 1, b: 11 };
-        let a = test.validate().unwrap_err().localize(&get_bundle());
+        let a = test.validate().unwrap_err().localize(&get_bundle(
+            ["hello-world = Hello, world!", "intro = Welcome, { $name }."].join("\n"),
+        ));
+
         assert_eq!(
             a.to_string(),
             json!({