Struct UpdateCatalogOptions 

pub struct UpdateCatalogOptions<'a> {
    pub locale: Option<&'a str>,
    pub source_locale: &'a str,
    pub input: CatalogUpdateInput,
    pub existing: Option<&'a str>,
    pub mode: CatalogMode,
    pub obsolete_strategy: ObsoleteStrategy,
    pub overwrite_source_translations: bool,
    pub render: RenderOptions<'a>,
}

Options for in-memory catalog updates.

Fields

locale: Option<&'a str>

Locale of the catalog being updated. When None, Ferrocat infers it from the existing file.

source_locale: &'a str

Source locale used for source-side semantics and fallback handling.

input: CatalogUpdateInput

Extracted messages to merge into the catalog.

existing: Option<&'a str>

Existing catalog content, when updating an in-memory catalog.

mode: CatalogMode

High-level catalog mode used when parsing, merging, and rendering the catalog.

obsolete_strategy: ObsoleteStrategy

Strategy for messages absent from the extracted input.

overwrite_source_translations: bool

Whether source-locale translations should be refreshed from the extracted source strings.

render: RenderOptions<'a>

Shared serialization options for the rendered catalog.

Implementations

impl<'a> UpdateCatalogOptions<'a>

pub fn new( source_locale: &'a str, input: impl Into<CatalogUpdateInput>, ) -> UpdateCatalogOptions<'a>

Creates in-memory update options with required fields set.

Optional fields use the same defaults that the previous Default implementation provided.

Examples found in repository

examples/ndjson_with_mt_metadata.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let hash = machine_translation_hash(EffectiveTranslationRef::Singular("Hallo"));
    let existing = format!(
        concat!(
            "---\n",
            "format: ferrocat.ndjson.v1\n",
            "locale: de\n",
            "source_locale: en\n",
            "---\n",
            "{{\"id\":\"Hello\",\"str\":\"Hallo\",\"mt\":{{\"model\":\"example/mt\",\"confidence\":92,\"hash\":\"{hash}\"}}}}\n"
        ),
        hash = hash
    );

    let result = update_catalog(UpdateCatalogOptions {
        locale: Some("de"),
        mode: CatalogMode::IcuNdjson,
        existing: Some(&existing),
        input: CatalogUpdateInput::SourceFirst(vec![SourceExtractedMessage {
            msgid: "Hello".to_owned(),
            ..SourceExtractedMessage::default()
        }]),
        ..UpdateCatalogOptions::new("en", CatalogUpdateInput::default())
    })?;

    assert!(result.content.contains("format: ferrocat.ndjson.v1"));
    assert!(result.content.contains("\"model\":\"example/mt\""));
    assert!(result.content.contains(&hash));

    println!("{}", result.content);
    Ok(())
}

Trait Implementations

impl<'a> Clone for UpdateCatalogOptions<'a>

fn clone(&self) -> UpdateCatalogOptions<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for UpdateCatalogOptions<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Eq for UpdateCatalogOptions<'a>

impl<'a> PartialEq for UpdateCatalogOptions<'a>

fn eq(&self, other: &UpdateCatalogOptions<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for UpdateCatalogOptions<'a>