Skip to content

Commit cfda316

Browse files
zbranieckizbraniecki
committed
Update FluentBundle to the latest API
1 parent dc3a8da commit cfda316

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

55 files changed

+2609
-1854
lines changed

‎fluent-bundle/Cargo.toml

+6-3
Original file line numberDiff line numberDiff line change
@@ -17,9 +17,6 @@ readme = "README.md"
1717
keywords = ["localization", "l10n", "i18n", "intl", "internationalization"]
1818
categories = ["localization", "internationalization"]
1919

20-
[dev-dependencies]
21-
criterion = "^0.2"
22-
2320
[dependencies]
2421
fluent-locale = "^0.4.1"
2522
fluent-syntax = "^0.9"
@@ -29,6 +26,12 @@ intl_pluralrules = "^1.0"
2926
rental = "^0.5.4"
3027
smallvec = "0.6.10"
3128

29+
[dev-dependencies]
30+
criterion = "^0.2"
31+
serde = { version = "^1.0", features = ["derive"] }
32+
serde_yaml = "^0.8"
33+
rand = "^0.7.0"
34+
3235
[[bench]]
3336
name = "resolver"
3437
harness = false

‎fluent-bundle/benches/resolver.rs

+22-12
Original file line numberDiff line numberDiff line change
@@ -38,20 +38,23 @@ fn get_ids(res: &FluentResource) -> Vec<String> {
3838
.collect()
3939
}
4040

41-
fn get_args(name: &str) -> Option<HashMap<&'static str, FluentValue>> {
41+
fn get_args(name: &str) -> Option<HashMap<String, FluentValue>> {
4242
match name {
4343
"preferences" => {
4444
let mut prefs_args = HashMap::new();
45-
prefs_args.insert("name", FluentValue::from("John"));
46-
prefs_args.insert("tabCount", FluentValue::from(5));
47-
prefs_args.insert("count", FluentValue::from(3));
48-
prefs_args.insert("version", FluentValue::from("65.0"));
49-
prefs_args.insert("path", FluentValue::from("/tmp"));
50-
prefs_args.insert("num", FluentValue::from(4));
51-
prefs_args.insert("email", FluentValue::from("[email protected]"));
52-
prefs_args.insert("value", FluentValue::from(4.5));
53-
prefs_args.insert("unit", FluentValue::from("mb"));
54-
prefs_args.insert("service-name", FluentValue::from("Mozilla Disk"));
45+
prefs_args.insert("name".to_string(), FluentValue::from("John"));
46+
prefs_args.insert("tabCount".to_string(), FluentValue::from(5));
47+
prefs_args.insert("count".to_string(), FluentValue::from(3));
48+
prefs_args.insert("version".to_string(), FluentValue::from("65.0"));
49+
prefs_args.insert("path".to_string(), FluentValue::from("/tmp"));
50+
prefs_args.insert("num".to_string(), FluentValue::from(4));
51+
prefs_args.insert("email".to_string(), FluentValue::from("[email protected]"));
52+
prefs_args.insert("value".to_string(), FluentValue::from(4.5));
53+
prefs_args.insert("unit".to_string(), FluentValue::from("mb"));
54+
prefs_args.insert(
55+
"service-name".to_string(),
56+
FluentValue::from("Mozilla Disk"),
57+
);
5558
Some(prefs_args)
5659
}
5760
_ => None,
@@ -91,7 +94,14 @@ fn resolver_bench(c: &mut Criterion) {
9194

9295
b.iter(|| {
9396
for id in &ids {
94-
let (_msg, errors) = bundle.compound(id, args.as_ref()).expect("Message found");
97+
let msg = bundle.get_message(id).expect("Message found");
98+
let mut errors = vec![];
99+
if let Some(value) = msg.value {
100+
let _ = bundle.format_pattern(value, args.as_ref(), &mut errors);
101+
}
102+
for (_, value) in msg.attributes {
103+
let _ = bundle.format_pattern(value, args.as_ref(), &mut errors);
104+
}
95105
assert!(errors.len() == 0, "Resolver errors: {:#?}", errors);
96106
}
97107
})

‎fluent-bundle/examples/external_arguments.rs

+17-14
Original file line numberDiff line numberDiff line change
@@ -20,23 +20,26 @@ unread-emails =
2020
.expect("Failed to add FTL resources to the bundle.");
2121

2222
let mut args = HashMap::new();
23-
args.insert("name", FluentValue::from("John"));
23+
args.insert("name".to_string(), FluentValue::from("John"));
2424

25-
match bundle.format("hello-world", Some(&args)) {
26-
Some((value, _)) => println!("{}", value),
27-
_ => println!("None"),
28-
}
25+
let msg = bundle.get_message("hello-world").expect("Message exists");
26+
let mut errors = vec![];
27+
let pattern = msg.value.expect("Message has a value");
28+
let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
29+
println!("{}", value);
2930

30-
match bundle.format("ref", Some(&args)) {
31-
Some((value, _)) => println!("{}", value),
32-
_ => println!("None"),
33-
}
31+
let msg = bundle.get_message("ref").expect("Message exists");
32+
let mut errors = vec![];
33+
let pattern = msg.value.expect("Message has a value");
34+
let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
35+
println!("{}", value);
3436

3537
let mut args = HashMap::new();
36-
args.insert("emailCount", FluentValue::into_number("1.0"));
38+
args.insert("emailCount".to_string(), FluentValue::into_number("1.0"));
3739

38-
match bundle.format("unread-emails", Some(&args)) {
39-
Some((value, _)) => println!("{}", value),
40-
None => println!("None"),
41-
}
40+
let msg = bundle.get_message("unread-emails").expect("Message exists");
41+
let mut errors = vec![];
42+
let pattern = msg.value.expect("Message has a value");
43+
let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
44+
println!("{}", value);
4245
}

‎fluent-bundle/examples/functions.rs

+16-11
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ fn main() {
2828
}
2929
}
3030

31-
FluentValue::None()
31+
FluentValue::None
3232
})
3333
.expect("Failed to add a function to the bundle.");
3434

@@ -39,7 +39,7 @@ fn main() {
3939
Some(FluentValue::String(ref string)) => {
4040
format!("All your base belong to {}", string).into()
4141
}
42-
_ => FluentValue::None(),
42+
_ => FluentValue::None,
4343
};
4444
})
4545
.expect("Failed to add a function to the bundle.");
@@ -54,18 +54,23 @@ fn main() {
5454
.add_resource(res3)
5555
.expect("Failed to add FTL resources to the bundle.");
5656

57-
let (value, _) = bundle
58-
.format("hello-world", None)
59-
.expect("Failed to format a message.");
57+
let msg = bundle.get_message("hello-world").expect("Message exists");
58+
let mut errors = vec![];
59+
let pattern = msg.value.expect("Message has a value");
60+
let value = bundle.format_pattern(&pattern, None, &mut errors);
6061
assert_eq!(&value, "Hey there! \u{2068}I'm a function!\u{2069}");
6162

62-
let (value, _) = bundle
63-
.format("meaning-of-life", None)
64-
.expect("Failed to format a message.");
63+
let msg = bundle
64+
.get_message("meaning-of-life")
65+
.expect("Message exists");
66+
let mut errors = vec![];
67+
let pattern = msg.value.expect("Message has a value");
68+
let value = bundle.format_pattern(&pattern, None, &mut errors);
6569
assert_eq!(&value, "The answer to life, the universe, and everything");
6670

67-
let (value, _) = bundle
68-
.format("all-your-base", None)
69-
.expect("Failed to format a message.");
71+
let msg = bundle.get_message("all-your-base").expect("Message exists");
72+
let mut errors = vec![];
73+
let pattern = msg.value.expect("Message has a value");
74+
let value = bundle.format_pattern(&pattern, None, &mut errors);
7075
assert_eq!(&value, "All your base belong to us");
7176
}

‎fluent-bundle/examples/hello.rs

+5-3
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,10 @@ fn main() {
77
bundle
88
.add_resource(&res)
99
.expect("Failed to add FTL resources to the bundle.");
10-
let (value, _) = bundle
11-
.format("hello-world", None)
12-
.expect("Failed to format a message.");
10+
11+
let msg = bundle.get_message("hello-world").expect("Message exists");
12+
let mut errors = vec![];
13+
let pattern = msg.value.expect("Message has a value");
14+
let value = bundle.format_pattern(&pattern, None, &mut errors);
1315
assert_eq!(&value, "Hello, world!");
1416
}

‎fluent-bundle/examples/message_reference.rs

+10-8
Original file line numberDiff line numberDiff line change
@@ -15,13 +15,15 @@ bazbar = { baz } Bar
1515
.add_resource(res)
1616
.expect("Failed to add FTL resources to the bundle.");
1717

18-
match bundle.format("foobar", None) {
19-
Some((value, _)) => println!("{}", value),
20-
_ => println!("None"),
21-
}
18+
let msg = bundle.get_message("foobar").expect("Message exists");
19+
let mut errors = vec![];
20+
let pattern = msg.value.expect("Message has a value");
21+
let value = bundle.format_pattern(&pattern, None, &mut errors);
22+
println!("{}", value);
2223

23-
match bundle.format("bazbar", None) {
24-
Some((value, _)) => println!("{}", value),
25-
_ => println!("None"),
26-
}
24+
let msg = bundle.get_message("bazbar").expect("Message exists");
25+
let mut errors = vec![];
26+
let pattern = msg.value.expect("Message has a value");
27+
let value = bundle.format_pattern(&pattern, None, &mut errors);
28+
println!("{}", value);
2729
}

‎fluent-bundle/examples/selector.rs

+11-9
Original file line numberDiff line numberDiff line change
@@ -21,16 +21,18 @@ hello-world2 = Hello { $name ->
2121
.add_resource(res)
2222
.expect("Failed to add FTL resources to the bundle.");
2323

24-
match bundle.format("hello-world", None) {
25-
Some((value, _)) => println!("{}", value),
26-
_ => println!("None"),
27-
}
24+
let msg = bundle.get_message("hello-world").expect("Message exists");
25+
let mut errors = vec![];
26+
let pattern = msg.value.expect("Message has a value");
27+
let value = bundle.format_pattern(&pattern, None, &mut errors);
28+
println!("{}", value);
2829

2930
let mut args = HashMap::new();
30-
args.insert("name", FluentValue::from("moon"));
31+
args.insert("name".to_string(), FluentValue::from("moon"));
3132

32-
match bundle.format("hello-world2", Some(&args)) {
33-
Some((value, _)) => println!("{}", value),
34-
_ => println!("None"),
35-
}
33+
let msg = bundle.get_message("hello-world2").expect("Message exists");
34+
let mut errors = vec![];
35+
let pattern = msg.value.expect("Message has a value");
36+
let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
37+
println!("{}", value);
3638
}

‎fluent-bundle/examples/simple-app.rs

+20-13
Original file line numberDiff line numberDiff line change
@@ -130,29 +130,36 @@ fn main() {
130130
// 7.2. Construct a map of arguments
131131
// to format the message.
132132
let mut args = HashMap::new();
133-
args.insert("input", FluentValue::from(i));
134-
args.insert("value", FluentValue::from(collatz(i)));
133+
args.insert("input".to_string(), FluentValue::from(i));
134+
args.insert("value".to_string(), FluentValue::from(collatz(i)));
135135
// 7.3. Format the message.
136-
let (value, _) = bundle
137-
.format("response-msg", Some(&args))
138-
.expect("Failed to format a message.");
136+
let mut errors = vec![];
137+
let msg = bundle.get_message("response-msg").expect("Message exists");
138+
let pattern = msg.value.expect("Message has a value");
139+
let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
139140
println!("{}", value);
140141
}
141142
Err(err) => {
142143
let mut args = HashMap::new();
143-
args.insert("input", FluentValue::from(input.as_str()));
144-
args.insert("reason", FluentValue::from(err.to_string()));
145-
let (value, _) = bundle
146-
.format("input-parse-error-msg", Some(&args))
147-
.expect("Failed to format a message.");
144+
args.insert("input".to_string(), FluentValue::from(input.as_str()));
145+
args.insert("reason".to_string(), FluentValue::from(err.to_string()));
146+
let mut errors = vec![];
147+
let msg = bundle
148+
.get_message("input-parse-error-msg")
149+
.expect("Message exists");
150+
let pattern = msg.value.expect("Message has a value");
151+
let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
148152
println!("{}", value);
149153
}
150154
}
151155
}
152156
None => {
153-
let (value, _) = bundle
154-
.format("missing-arg-error", None)
155-
.expect("Failed to format a message.");
157+
let mut errors = vec![];
158+
let msg = bundle
159+
.get_message("missing-arg-error")
160+
.expect("Message exists");
161+
let pattern = msg.value.expect("Message has a value");
162+
let value = bundle.format_pattern(&pattern, None, &mut errors);
156163
println!("{}", value);
157164
}
158165
}

0 commit comments

Comments
 (0)