path: root/intl/l10n/rust/l10nregistry-rs/src/registry/synchronous.rs

use super::{BundleAdapter, L10nRegistry, MetaSources};
use crate::env::ErrorReporter;
use crate::errors::L10nRegistryError;
use crate::fluent::{FluentBundle, FluentError};
use crate::solver::{SerialProblemSolver, SyncTester};
use crate::source::ResourceOption;
use fluent_fallback::{generator::BundleIterator, types::ResourceId};
use unic_langid::LanguageIdentifier;

impl MetaSources {
    pub(crate) fn bundle_from_order<P, B>(
        &self,
        metasource: usize,
        locale: LanguageIdentifier,
        source_order: &[usize],
        resource_ids: &[ResourceId],
        error_reporter: &P,
        bundle_adapter: Option<&B>,
    ) -> Option<Result<FluentBundle, (FluentBundle, Vec<FluentError>)>>
    where
        P: ErrorReporter,
        B: BundleAdapter,
    {
        let mut bundle = FluentBundle::new(vec![locale.clone()]);

        if let Some(bundle_adapter) = bundle_adapter {
            bundle_adapter.adapt_bundle(&mut bundle);
        }

        let mut errors = vec![];

        for (&source_idx, resource_id) in source_order.iter().zip(resource_ids.iter()) {
            let source = self.filesource(metasource, source_idx);
            if let ResourceOption::Some(res) =
                source.fetch_file_sync(&locale, resource_id, /* overload */ true)
            {
                if source.options.allow_override {
                    bundle.add_resource_overriding(res);
                } else if let Err(err) = bundle.add_resource(res) {
                    errors.extend(err.into_iter().map(|error| L10nRegistryError::FluentError {
                        resource_id: resource_id.clone(),
                        loc: None,
                        error,
                    }));
                }
            } else if resource_id.is_required() {
                return None;
            }
        }

        if !errors.is_empty() {
            error_reporter.report_errors(errors);
        }
        Some(Ok(bundle))
    }
}

impl<P, B> L10nRegistry<P, B>
where
    P: Clone,
    B: Clone,
{
    /// A test-only function for easily generating bundles for a single langid.
    #[cfg(feature = "test-fluent")]
    pub fn generate_bundles_for_lang_sync(
        &self,
        langid: LanguageIdentifier,
        resource_ids: Vec<ResourceId>,
    ) -> GenerateBundlesSync<P, B> {
        let lang_ids = vec![langid];

        GenerateBundlesSync::new(self.clone(), lang_ids.into_iter(), resource_ids)
    }

    /// Wiring for hooking up the synchronous bundle generation to the
    /// [BundleGenerator] trait.
    pub fn generate_bundles_sync(
        &self,
        locales: std::vec::IntoIter<LanguageIdentifier>,
        resource_ids: Vec<ResourceId>,
    ) -> GenerateBundlesSync<P, B> {
        GenerateBundlesSync::new(self.clone(), locales, resource_ids)
    }
}

enum State {
    Empty,
    Locale(LanguageIdentifier),
    Solver {
        locale: LanguageIdentifier,
        solver: SerialProblemSolver,
    },
}

impl Default for State {
    fn default() -> Self {
        Self::Empty
    }
}

impl State {
    fn get_locale(&self) -> &LanguageIdentifier {
        match self {
            Self::Locale(locale) => locale,
            Self::Solver { locale, .. } => locale,
            Self::Empty => unreachable!("Attempting to get a locale for an empty state."),
        }
    }

    fn take_solver(&mut self) -> SerialProblemSolver {
        replace_with::replace_with_or_default_and_return(self, |self_| match self_ {
            Self::Solver { locale, solver } => (solver, Self::Locale(locale)),
            _ => unreachable!("Attempting to take a solver in an invalid state."),
        })
    }

    fn put_back_solver(&mut self, solver: SerialProblemSolver) {
        replace_with::replace_with_or_default(self, |self_| match self_ {
            Self::Locale(locale) => Self::Solver { locale, solver },
            _ => unreachable!("Attempting to put back a solver in an invalid state."),
        })
    }
}

pub struct GenerateBundlesSync<P, B> {
    reg: L10nRegistry<P, B>,
    locales: std::vec::IntoIter<LanguageIdentifier>,
    current_metasource: usize,
    resource_ids: Vec<ResourceId>,
    state: State,
}

impl<P, B> GenerateBundlesSync<P, B> {
    fn new(
        reg: L10nRegistry<P, B>,
        locales: std::vec::IntoIter<LanguageIdentifier>,
        resource_ids: Vec<ResourceId>,
    ) -> Self {
        Self {
            reg,
            locales,
            current_metasource: 0,
            resource_ids,
            state: State::Empty,
        }
    }
}

impl<P, B> SyncTester for GenerateBundlesSync<P, B> {
    fn test_sync(&self, res_idx: usize, source_idx: usize) -> bool {
        let locale = self.state.get_locale();
        let resource_id = &self.resource_ids[res_idx];
        !self
            .reg
            .try_borrow_metasources()
            .expect("Unable to get the MetaSources.")
            .filesource(self.current_metasource, source_idx)
            .fetch_file_sync(locale, resource_id, /* overload */ true)
            .is_required_and_missing()
    }
}

impl<P, B> BundleIterator for GenerateBundlesSync<P, B>
where
    P: ErrorReporter,
{
    fn prefetch_sync(&mut self) {
        if let State::Solver { .. } = self.state {
            let mut solver = self.state.take_solver();
            if let Err(idx) = solver.try_next(self, true) {
                self.reg
                    .shared
                    .provider
                    .report_errors(vec![L10nRegistryError::MissingResource {
                        locale: self.state.get_locale().clone(),
                        resource_id: self.resource_ids[idx].clone(),
                    }]);
            }
            self.state.put_back_solver(solver);
            return;
        }

        if let Some(locale) = self.locales.next() {
            let mut solver = SerialProblemSolver::new(
                self.resource_ids.len(),
                self.reg
                    .try_borrow_metasources()
                    .expect("Unable to get the MetaSources.")
                    .get(self.current_metasource)
                    .len(),
            );
            self.state = State::Locale(locale.clone());
            if let Err(idx) = solver.try_next(self, true) {
                self.reg
                    .shared
                    .provider
                    .report_errors(vec![L10nRegistryError::MissingResource {
                        locale,
                        resource_id: self.resource_ids[idx].clone(),
                    }]);
            }
            self.state.put_back_solver(solver);
        }
    }
}

impl<P, B> Iterator for GenerateBundlesSync<P, B>
where
    P: ErrorReporter,
    B: BundleAdapter,
{
    type Item = Result<FluentBundle, (FluentBundle, Vec<FluentError>)>;

    /// Synchronously generate a bundle based on a solver.
    fn next(&mut self) -> Option<Self::Item> {
        let metasources = self
            .reg
            .try_borrow_metasources()
            .expect("Unable to get the MetaSources.");

        if metasources.is_empty() {
            // There are no metasources available, so no bundles can be generated.
            return None;
        }

        loop {
            if let State::Solver { .. } = self.state {
                // A solver has already been set up, continue iterating through the
                // resources and generating a bundle.
                let mut solver = self.state.take_solver();
                let solver_result = solver.try_next(self, false);

                if let Ok(Some(order)) = solver_result {
                    // The solver resolved an ordering, and a bundle may be able
                    // to be generated.

                    let bundle = metasources.bundle_from_order(
                        self.current_metasource,
                        self.state.get_locale().clone(),
                        &order,
                        &self.resource_ids,
                        &self.reg.shared.provider,
                        self.reg.shared.bundle_adapter.as_ref(),
                    );

                    self.state.put_back_solver(solver);

                    if bundle.is_some() {
                        // The bundle was successfully generated.
                        return bundle;
                    }

                    // No bundle was generated, continue on.
                    continue;
                }

                // There is no bundle ordering available.

                if self.current_metasource > 0 {
                    // There are more metasources, create a new solver and try the
                    // next metasource. If there is an error in the solver_result
                    // ignore it for now, since there are more metasources.
                    self.current_metasource -= 1;
                    let solver = SerialProblemSolver::new(
                        self.resource_ids.len(),
                        metasources.get(self.current_metasource).len(),
                    );
                    self.state = State::Solver {
                        locale: self.state.get_locale().clone(),
                        solver,
                    };
                    continue;
                }

                if let Err(idx) = solver_result {
                    // Since there are no more metasources, and there is an error,
                    // report it instead of ignoring it.
                    self.reg.shared.provider.report_errors(vec![
                        L10nRegistryError::MissingResource {
                            locale: self.state.get_locale().clone(),
                            resource_id: self.resource_ids[idx].clone(),
                        },
                    ]);
                }

                self.state = State::Empty;
                continue;
            }

            // Try the next locale, or break out of the loop if there are none left.
            let locale = self.locales.next()?;

            // Restart at the end of the metasources for this locale, and iterate
            // backwards.
            let last_metasource_idx = metasources.len() - 1;
            self.current_metasource = last_metasource_idx;

            let solver = SerialProblemSolver::new(
                self.resource_ids.len(),
                metasources.get(self.current_metasource).len(),
            );

            // Continue iterating on the next solver.
            self.state = State::Solver { locale, solver };
        }
    }
}