fluent_typed_codegen 0.1.0

Automatic Fluent catalog discovery and typed code generation for Cargo
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Package metadata locating translation sources for generation.
use crate::paths;
use std::path::{Path, PathBuf};
use toml_edit::DocumentMut;

/// Portable paths locating a consuming package's assets and catalog configuration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Settings {
	/// Asset directory relative to the consuming Cargo package, e.g. `assets`.
	pub asset_root: PathBuf,
	/// TOML configuration path relative to `asset_root`, e.g. `localizations/localization.toml`.
	pub catalog: PathBuf,
}

impl Settings {
	/// Read `[package.metadata.localization]`; no list of languages is required.
	///
	/// # Errors
	/// Rejects invalid TOML, unknown/missing fields and nonportable or escaping paths.
	/// Language settings belong to `localization.toml`, not Cargo metadata.
	///
	/// ```
	/// use fluent_typed_codegen::Settings;
	/// let settings = Settings::from_manifest(r#"
	/// [package.metadata.localization]
	/// asset-root = "assets"
	/// catalog = "localizations/localization.toml"
	/// "#)?;
	/// assert_eq!(settings.asset_root.to_str(), Some("assets"));
	/// # Ok::<(), String>(())
	/// ```
	pub fn from_manifest(source: &str) -> Result<Self, String> {
		let document = source
			.parse::<DocumentMut>()
			.map_err(|error| error.to_string())?;
		let table = document
			.get("package")
			.and_then(|item| item.get("metadata"))
			.and_then(|item| item.get("localization"))
			.and_then(|item| item.as_table())
			.ok_or("missing [package.metadata.localization] in Cargo.toml")?;

		for (key, _) in table {
			if !["asset-root", "catalog"].contains(&key) {
				return Err(format!("unknown localization setting: {key}"));
			}
		}

		let value = |key: &str| {
			table
				.get(key)
				.and_then(|item| item.as_str())
				.filter(|value| !value.trim().is_empty())
				.map(str::to_owned)
				.ok_or_else(|| format!("localization.{key} must be a nonempty string"))
		};

		let settings = Self {
			asset_root: value("asset-root")?.into(),
			catalog: value("catalog")?.into(),
		};
		settings.validate()?;
		Ok(settings)
	}

	pub(super) fn validate(&self) -> Result<(), String> {
		paths::validate_relative(&self.asset_root, "asset-root")?;
		paths::validate_relative(&self.catalog, "catalog")?;

		if self
			.catalog
			.extension()
			.is_none_or(|extension| extension != "toml")
		{
			return Err("localization.catalog must name a TOML configuration file".into());
		}

		Ok(())
	}

	pub(super) fn catalog_path(&self, package: &Path) -> PathBuf {
		package.join(&self.asset_root).join(&self.catalog)
	}
}