Struct CatalogAuditOptions 

pub struct CatalogAuditOptions<'a> {
    pub source_locale: &'a str,
    pub locales: &'a [&'a str],
    pub metadata: &'a [MessageMetadataInput],
    pub checks: CatalogAuditChecks,
}

Options controlling catalog audit checks.

Fields

source_locale: &'a str

Source locale used as the expected message set.

locales: &'a [&'a str]

Optional target locale filter. Empty means all non-source locales present in catalogs.

metadata: &'a [MessageMetadataInput]

Optional source-side semantic metadata records.

checks: CatalogAuditChecks

Individual audit checks to run.

Implementations

impl<'a> CatalogAuditOptions<'a>

pub fn new(source_locale: &'a str) -> CatalogAuditOptions<'a>

Creates audit options with the required source locale set.

Examples found in repository

examples/release_audit.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let source = catalog("msgid \"Checkout\"\nmsgstr \"Checkout\"\n", "en")?;
    let target = catalog("msgid \"Checkout\"\nmsgstr \"\"\n", "de")?;

    let report = audit_catalogs(&[&source, &target], &CatalogAuditOptions::new("en"))?;

    assert!(report.has_errors());
    assert!(
        report
            .diagnostics
            .iter()
            .any(|diagnostic| diagnostic.code == "catalog.empty_translation")
    );

    for diagnostic in &report.diagnostics {
        println!("{}: {}", diagnostic.code, diagnostic.message);
    }

    Ok(())
}

Trait Implementations

impl<'a> Clone for CatalogAuditOptions<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CatalogAuditOptions<'a>

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

Formats the value using the given formatter.

impl<'a> Default for CatalogAuditOptions<'a>

fn default() -> CatalogAuditOptions<'a>

Returns the “default value” for a type.

impl<'a> Eq for CatalogAuditOptions<'a>

impl<'a> PartialEq for CatalogAuditOptions<'a>

fn eq(&self, other: &CatalogAuditOptions<'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 CatalogAuditOptions<'a>