Add docs for FluentBundle

.gitignore

@@ -1,3 +1,4 @@
 /target/
+*/target/
 **/*.rs.bk
 Cargo.lock

Cargo.toml

@@ -1,5 +1,7 @@
 [workspace]
 members = [
+    "fluent-syntax",
+    "fluent-bundle",
+    "fluent-cli",
     "fluent",
-    "fluent-syntax"
 ]

fluent-bundle/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "fluent-bundle"
+description = """
+A localization system designed to unleash the entire expressive power of
+natural language translations.
+"""
+version = "0.4.3"
+edition = "2018"
+authors = [
+    "Zibi Braniecki <[email protected]>",
+    "Staś Małolepszy <[email protected]>"
+]
+homepage = "http://www.projectfluent.org"
+license = "Apache-2.0/MIT"
+repository = "https://github.com/projectfluent/fluent-rs"
+readme = "README.md"
+keywords = ["localization", "l10n", "i18n", "intl", "internationalization"]
+categories = ["localization", "internationalization"]
+
+[dependencies]
+fluent-locale = "^0.4.1"
+fluent-syntax = { path = "../fluent-syntax" }
+failure = "^0.1"
+failure_derive = "^0.1"
+intl_pluralrules = "^1.0"
+rental = "^0.5.2"

fluent/README.md → fluent-bundle/README.md

@@ -22,7 +22,7 @@ Usage
 -----
 
 ```rust
-use fluent::bundle::FluentBundle;
+use fluent_bundle::FluentBundle;
 
 fn main() {
     let mut bundle = FluentBundle::new(&["en-US"]);

fluent/benches/lib.rs → fluent-bundle/benches/lib.rs

@@ -1,63 +1,70 @@
 #![feature(test)]
 
-extern crate fluent;
-extern crate fluent_syntax;
 extern crate test;
 
-use fluent::bundle::FluentBundle;
-use fluent_syntax::{ast, parser::parse};
+use fluent_bundle::bundle::FluentBundle;
+use fluent_bundle::resource::FluentResource;
+use fluent_syntax::ast;
 use std::fs::File;
 use std::io;
 use std::io::Read;
 use test::Bencher;
 
 fn read_file(path: &str) -> Result<String, io::Error> {
-    let mut f = try!(File::open(path));
+    let mut f = File::open(path)?;
     let mut s = String::new();
-    try!(f.read_to_string(&mut s));
+    f.read_to_string(&mut s)?;
     Ok(s)
 }
 
 #[bench]
 fn bench_simple_format(b: &mut Bencher) {
     let source = read_file("./benches/simple.ftl").expect("Couldn't load file");
-    let resource = parse(&source).unwrap();
+    let res = FluentResource::try_new(source).expect("Couldn't parse an FTL source");
 
     let mut ids = Vec::new();
 
-    for entry in resource.body {
+    for entry in &res.ast().body {
         match entry {
-            ast::Entry::Message(ast::Message { id, .. }) => ids.push(id.name),
+            ast::ResourceEntry::Entry(ast::Entry::Message(ast::Message { id, .. })) => {
+                ids.push(id.name)
+            }
             _ => continue,
         };
     }
 
     let mut bundle = FluentBundle::new(&["x-testing"]);
-    bundle.add_messages(&source).unwrap();
+    bundle
+        .add_resource(&res)
+        .expect("Couldn't add FluentResource to the FluentBundle");
 
     b.iter(|| {
         for id in &ids {
-            bundle.format(id.as_str(), None);
+            bundle.format(id, None);
         }
     });
 }
 
 #[bench]
 fn bench_menubar_format(b: &mut Bencher) {
     let source = read_file("./benches/menubar.ftl").expect("Couldn't load file");
-    let resource = parse(&source).unwrap();
+    let res = FluentResource::try_new(source).expect("Couldn't parse an FTL source");
 
     let mut ids = Vec::new();
 
-    for entry in resource.body {
+    for entry in &res.ast().body {
         match entry {
-            ast::Entry::Message(ast::Message { id, .. }) => ids.push(id.name),
+            ast::ResourceEntry::Entry(ast::Entry::Message(ast::Message { id, .. })) => {
+                ids.push(id.name)
+            }
             _ => continue,
         };
     }
 
     let mut bundle = FluentBundle::new(&["x-testing"]);
-    bundle.add_messages(&source).unwrap();
+    bundle
+        .add_resource(&res)
+        .expect("Couldn't add FluentResource to the FluentBundle");
 
     b.iter(|| {
         for id in &ids {
@@ -66,7 +73,7 @@ fn bench_menubar_format(b: &mut Bencher) {
             // widgets may only expect attributes and they shouldn't be forced to display a value.
             // Here however it doesn't matter because we know for certain that the message for `id`
             // exists.
-            bundle.format_message(id.as_str(), None);
+            bundle.format_message(id, None);
         }
     });
 }

fluent/examples/external_arguments.rs → fluent-bundle/examples/external_arguments.rs

@@ -1,24 +1,24 @@
-extern crate fluent;
-
-use fluent::bundle::FluentBundle;
-use fluent::types::FluentValue;
+use fluent_bundle::bundle::FluentBundle;
+use fluent_bundle::resource::FluentResource;
+use fluent_bundle::types::FluentValue;
 use std::collections::HashMap;
 
 fn main() {
-    let mut bundle = FluentBundle::new(&["en"]);
-    bundle
-        .add_messages(
-            "
+    let res = FluentResource::try_new(
+        "
 hello-world = Hello { $name }
 ref = The previous message says { hello-world }
 unread-emails =
     { $emailCount ->
         [one] You have { $emailCount } unread email
        *[other] You have { $emailCount } unread emails
     }
-",
-        )
-        .unwrap();
+"
+        .to_owned(),
+    )
+    .unwrap();
+    let mut bundle = FluentBundle::new(&["en"]);
+    bundle.add_resource(&res).unwrap();
 
     let mut args = HashMap::new();
     args.insert("name", FluentValue::from("John"));

fluent/examples/functions.rs → fluent-bundle/examples/functions.rs

@@ -1,9 +1,18 @@
-extern crate fluent;
-
-use fluent::bundle::FluentBundle;
-use fluent::types::FluentValue;
+use fluent_bundle::bundle::FluentBundle;
+use fluent_bundle::resource::FluentResource;
+use fluent_bundle::types::FluentValue;
 
 fn main() {
+    // We define the resources here so that they outlive
+    // the bundle.
+    let res1 = FluentResource::try_new("hello-world = Hey there! { HELLO() }".to_owned()).unwrap();
+    let res2 =
+        FluentResource::try_new("meaning-of-life = { MEANING_OF_LIFE(42) }".to_owned()).unwrap();
+    let res3 = FluentResource::try_new(
+        "all-your-base = { BASE_OWNERSHIP(hello, ownership: \"us\") }".to_owned(),
+    )
+    .unwrap();
+
     let mut bundle = FluentBundle::new(&["en-US"]);
 
     // Test for a simple function that returns a string
@@ -40,15 +49,9 @@ fn main() {
         })
         .unwrap();
 
-    bundle
-        .add_messages("hello-world = Hey there! { HELLO() }")
-        .unwrap();
-    bundle
-        .add_messages("meaning-of-life = { MEANING_OF_LIFE(42) }")
-        .unwrap();
-    bundle
-        .add_messages("all-your-base = { BASE_OWNERSHIP(hello, ownership: \"us\") }")
-        .unwrap();
+    bundle.add_resource(&res1).unwrap();
+    bundle.add_resource(&res2).unwrap();
+    bundle.add_resource(&res3).unwrap();
 
     let value = bundle.format("hello-world", None);
     assert_eq!(

fluent-bundle/examples/hello.rs

@@ -0,0 +1,10 @@
+use fluent_bundle::bundle::FluentBundle;
+use fluent_bundle::resource::FluentResource;
+
+fn main() {
+    let res = FluentResource::try_new("hello-world = Hello, world!".to_owned()).unwrap();
+    let mut bundle = FluentBundle::new(&["en-US"]);
+    bundle.add_resource(&res).unwrap();
+    let (value, _) = bundle.format("hello-world", None).unwrap();
+    assert_eq!(&value, "Hello, world!");
+}

fluent/examples/message_reference.rs → fluent-bundle/examples/message_reference.rs

@@ -1,18 +1,19 @@
-extern crate fluent;
-
-use fluent::bundle::FluentBundle;
+use fluent_bundle::bundle::FluentBundle;
+use fluent_bundle::resource::FluentResource;
 
 fn main() {
-    let mut bundle = FluentBundle::new(&["x-testing"]);
-    bundle
-        .add_messages(
-            "
+    let res = FluentResource::try_new(
+        "
 foo = Foo
 foobar = { foo } Bar
 bazbar = { baz } Bar
-",
-        )
-        .unwrap();
+"
+        .to_owned(),
+    )
+    .unwrap();
+
+    let mut bundle = FluentBundle::new(&["x-testing"]);
+    bundle.add_resource(&res).unwrap();
 
     match bundle.format("foobar", None) {
         Some((value, _)) => println!("{}", value),

fluent-bundle/examples/resources/en-US/simple.ftl

@@ -0,0 +1,7 @@
+missing-arg-error = Error: Please provide a number as argument.
+input-parse-error = Error: Could not parse input `{ $input }`. Reason: { $reason }
+response-msg =
+    { $value ->
+        [one] "{ $input }" has one Collatz step.
+       *[other] "{ $input }" has { $value } Collatz steps.
+    }

fluent-bundle/examples/resources/pl/simple.ftl

@@ -0,0 +1,8 @@
+missing-arg-error = Błąd: Proszę wprowadzić liczbę jako argument.
+input-parse-error = Błąd: Nie udało się sparsować `{ $input }`. Powód: { $reason } 
+response-msg =
+    { $value ->
+        [one] "{ $input }" ma jeden krok Collatza.
+        [few] "{ $input }" ma { $value } kroki Collatza.
+       *[many] "{ $input }" ma { $value } kroków Collatza.
+    }

fluent/examples/selector.rs → fluent-bundle/examples/selector.rs

@@ -1,14 +1,11 @@
-extern crate fluent;
-
-use fluent::bundle::FluentBundle;
-use fluent::types::FluentValue;
+use fluent_bundle::bundle::FluentBundle;
+use fluent_bundle::resource::FluentResource;
+use fluent_bundle::types::FluentValue;
 use std::collections::HashMap;
 
 fn main() {
-    let mut bundle = FluentBundle::new(&["x-testing"]);
-    bundle
-        .add_messages(
-            "
+    let res = FluentResource::try_new(
+        "
 hello-world = Hello {
        *[one] World
         [two] Moon
@@ -18,9 +15,12 @@ hello-world2 = Hello { $name ->
        *[world] World
         [moon] Moon
     }
-",
-        )
-        .unwrap();
+    "
+        .to_owned(),
+    )
+    .unwrap();
+    let mut bundle = FluentBundle::new(&["x-testing"]);
+    bundle.add_resource(&res).unwrap();
 
     match bundle.format("hello-world", None) {
         Some((value, _)) => println!("{}", value),