| args.rs |
|
3045 |
| bundle.rs |
`FluentBundle` is a collection of localization messages in Fluent.
It stores a list of messages in a single locale which can reference one another, use the same
internationalization formatters, functions, scopeironmental variables and are expected to be used
together. |
22353 |
| concurrent.rs |
|
1780 |
| entry.rs |
`Entry` is used to store Messages, Terms and Functions in `FluentBundle` instances. |
1972 |
| errors.rs |
|
2615 |
| lib.rs |
Fluent is a modern localization system designed to improve how software is translated.
`fluent-bundle` is a mid-level component of the [Fluent Localization
System](https://www.projectfluent.org).
The crate builds on top of the low level [`fluent-syntax`](../fluent-syntax) package, and provides
foundational types and structures required for executing localization at runtime.
There are four core concepts to understand Fluent runtime:
* [`FluentMessage`] - A single translation unit
* [`FluentResource`] - A list of [`FluentMessage`] units
* [`FluentBundle`](crate::bundle::FluentBundle) - A collection of [`FluentResource`] lists
* [`FluentArgs`] - A list of elements used to resolve a [`FluentMessage`] value
## Example
```
use fluent_bundle::{FluentBundle, FluentValue, FluentResource, FluentArgs};
// Used to provide a locale for the bundle.
use unic_langid::langid;
// 1. Crate a FluentResource
let ftl_string = r#"
hello-world = Hello, world!
intro = Welcome, { $name }.
"#.to_string();
let res = FluentResource::try_new(ftl_string)
.expect("Failed to parse an FTL string.");
// 2. Crate a FluentBundle
let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);
// 3. Add the resource to the bundle
bundle
.add_resource(res)
.expect("Failed to add FTL resources to the bundle.");
// 4. Retrieve a FluentMessage from the bundle
let msg = bundle.get_message("hello-world")
.expect("Message doesn't exist.");
// 5. Format the value of the simple message
let mut errors = vec![];
let pattern = msg.value()
.expect("Message has no value.");
let value = bundle.format_pattern(&pattern, None, &mut errors);
assert_eq!(
bundle.format_pattern(&pattern, None, &mut errors),
"Hello, world!"
);
// 6. Format the value of the message with arguments
let mut args = FluentArgs::new();
args.set("name", "John");
let msg = bundle.get_message("intro")
.expect("Message doesn't exist.");
let pattern = msg.value()
.expect("Message has no value.");
// The FSI/PDI isolation marks ensure that the direction of
// the text from the variable is not affected by the translation.
assert_eq!(
bundle.format_pattern(&pattern, Some(&args), &mut errors),
"Welcome, \u{2068}John\u{2069}."
);
```
# Ergonomics & Higher Level APIs
Reading the example, you may notice how verbose it feels.
Many core methods are fallible, others accumulate errors, and there
are intermediate structures used in operations.
This is intentional as it serves as building blocks for variety of different
scenarios allowing implementations to handle errors, cache and
optimize results.
At the moment it is expected that users will use
the `fluent-bundle` crate directly, while the ecosystem
matures and higher level APIs are being developed. |
3983 |
| memoizer.rs |
|
540 |
| message.rs |
|
8710 |
| resolver |
|
|
| resource.rs |
|
4655 |
| types |
|
|