13221860010

Committed 09 Feb 2025 03:13AM CUT coverage: 89.64% (-0.04%) from 89.675%

Build # 13221860010

Build Type

Pull #378

github

Committed by

web-flow

Commit Message

Merge ee3bfef45 into f2033ce83

Pull Request Pull Request #378: deps: update `thiserror` to version 2

Run Details

3963 of 4421 relevant lines covered (89.64%)

3602.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.28

/fluent-fallback/src/localization.rs

use crate::{
    bundles::Bundles,
    env::LocalesProvider,
    generator::{BundleGenerator, BundleIterator, BundleStream},
    types::ResourceId,
};
use once_cell::sync::OnceCell;
use rustc_hash::FxHashSet;
use std::rc::Rc;

pub struct Localization<G, P>
where
    G: BundleGenerator<LocalesIter = P::Iter>,
    P: LocalesProvider,
{
    bundles: OnceCell<Rc<Bundles<G>>>,
    generator: G,
    provider: P,
    sync: bool,
    res_ids: FxHashSet<ResourceId>,
}

impl<G, P> Localization<G, P>
where
    G: BundleGenerator<LocalesIter = P::Iter> + Default,
    P: LocalesProvider + Default,
{
    pub fn new<I>(res_ids: I, sync: bool) -> Self
    where
        I: IntoIterator<Item = ResourceId>,
    {
        Self {
            bundles: OnceCell::new(),
            generator: G::default(),
            provider: P::default(),
            sync,
            res_ids: FxHashSet::from_iter(res_ids),
        }
    }
}

impl<G, P> Localization<G, P>
where
    G: BundleGenerator<LocalesIter = P::Iter>,
    P: LocalesProvider,
{
    pub fn with_env<I>(res_ids: I, sync: bool, provider: P, generator: G) -> Self
    where
        I: IntoIterator<Item = ResourceId>,
    {
        Self {
            bundles: OnceCell::new(),
            generator,
            provider,
            sync,
            res_ids: FxHashSet::from_iter(res_ids),
        }
    }

    pub fn is_sync(&self) -> bool {
        self.sync
    }

    pub fn add_resource_id<T: Into<ResourceId>>(&mut self, res_id: T) {
        self.res_ids.insert(res_id.into());
        self.on_change();
    }

    pub fn add_resource_ids(&mut self, res_ids: Vec<ResourceId>) {
        self.res_ids.extend(res_ids);
        self.on_change();
    }

    pub fn remove_resource_id<T: PartialEq<ResourceId>>(&mut self, res_id: T) -> usize {
        self.res_ids.retain(|x| !res_id.eq(x));
        self.on_change();
        self.res_ids.len()
    }

    pub fn remove_resource_ids(&mut self, res_ids: Vec<ResourceId>) -> usize {
        self.res_ids.retain(|x| !res_ids.contains(x));
        self.on_change();
        self.res_ids.len()
    }

    pub fn set_async(&mut self) {
        if self.sync {
            self.sync = false;
            self.on_change();
        }
    }

    pub fn on_change(&mut self) {
        self.bundles.take();
    }
}

impl<G, P> Localization<G, P>
where
    G: BundleGenerator<LocalesIter = P::Iter>,
    G::Iter: BundleIterator,
    P: LocalesProvider,
{
    pub fn prefetch_sync(&mut self) {
        let bundles = self.bundles();
        bundles.prefetch_sync();
    }
}

impl<G, P> Localization<G, P>
where
    G: BundleGenerator<LocalesIter = P::Iter>,
    G::Stream: BundleStream,
    P: LocalesProvider,
{
    pub async fn prefetch_async(&mut self) {
        let bundles = self.bundles();
        bundles.prefetch_async().await;
    }
}

impl<G, P> Localization<G, P>
where
    G: BundleGenerator<LocalesIter = P::Iter>,
    P: LocalesProvider,
{
    pub fn bundles(&self) -> &Rc<Bundles<G>> {
        self.bundles.get_or_init(|| {
            Rc::new(Bundles::new(
                self.sync,
                self.res_ids.clone(),
                &self.generator,
                &self.provider,
            ))
        })
    }
}

1	use crate::{
2	bundles::Bundles,
3	env::LocalesProvider,
4	generator::{BundleGenerator, BundleIterator, BundleStream},
5	types::ResourceId,
6	};
7	use once_cell::sync::OnceCell;
8	use rustc_hash::FxHashSet;
9	use std::rc::Rc;
10
11	pub struct Localization<G, P>
12	where
13	G: BundleGenerator<LocalesIter = P::Iter>,
14	P: LocalesProvider,
15	{
16	bundles: OnceCell<Rc<Bundles<G>>>,
17	generator: G,
18	provider: P,
19	sync: bool,
20	res_ids: FxHashSet<ResourceId>,
21	}
22
23	impl<G, P> Localization<G, P>
24	where
25	G: BundleGenerator<LocalesIter = P::Iter> + Default,
26	P: LocalesProvider + Default,
27	{
28	pub fn new<I>(res_ids: I, sync: bool) -> Self	×
29	where	×
30	I: IntoIterator<Item = ResourceId>,	×
31	{	×
32	Self {	×
33	bundles: OnceCell::new(),	×
34	generator: G::default(),	×
35	provider: P::default(),	×
36	sync,	×
37	res_ids: FxHashSet::from_iter(res_ids),	×
38	}	×
39	}	×
40	}
41
42	impl<G, P> Localization<G, P>
43	where
44	G: BundleGenerator<LocalesIter = P::Iter>,
45	P: LocalesProvider,
46	{
47	pub fn with_env<I>(res_ids: I, sync: bool, provider: P, generator: G) -> Self	10✔
48	where	10✔
49	I: IntoIterator<Item = ResourceId>,	10✔
50	{	10✔
51	Self {	10✔
52	bundles: OnceCell::new(),	10✔
53	generator,	10✔
54	provider,	10✔
55	sync,	10✔
56	res_ids: FxHashSet::from_iter(res_ids),	10✔
57	}	10✔
58	}	10✔
59
60	pub fn is_sync(&self) -> bool {	×
61	self.sync	×
62	}	×
63
64	pub fn add_resource_id<T: Into<ResourceId>>(&mut self, res_id: T) {	1✔
65	self.res_ids.insert(res_id.into());	1✔
66	self.on_change();	1✔
67	}	1✔
68
69	pub fn add_resource_ids(&mut self, res_ids: Vec<ResourceId>) {	×
70	self.res_ids.extend(res_ids);	×
71	self.on_change();	×
72	}	×
73
74	pub fn remove_resource_id<T: PartialEq<ResourceId>>(&mut self, res_id: T) -> usize {	×
75	self.res_ids.retain(\|x\| !res_id.eq(x));	×
76	self.on_change();	×
77	self.res_ids.len()	×
78	}	×
79
80	pub fn remove_resource_ids(&mut self, res_ids: Vec<ResourceId>) -> usize {	×
81	self.res_ids.retain(\|x\| !res_ids.contains(x));	×
82	self.on_change();	×
83	self.res_ids.len()	×
84	}	×
85
86	pub fn set_async(&mut self) {	×
87	if self.sync {	×
88	self.sync = false;	×
89	self.on_change();	×
90	}	×
91	}	×
92
93	pub fn on_change(&mut self) {	2✔
94	self.bundles.take();	2✔
95	}	2✔
96	}
97
98	impl<G, P> Localization<G, P>
99	where
100	G: BundleGenerator<LocalesIter = P::Iter>,
101	G::Iter: BundleIterator,
102	P: LocalesProvider,
103	{
104	pub fn prefetch_sync(&mut self) {	×
105	let bundles = self.bundles();	×
106	bundles.prefetch_sync();	×
107	}	×
108	}
109
110	impl<G, P> Localization<G, P>
111	where
112	G: BundleGenerator<LocalesIter = P::Iter>,
113	G::Stream: BundleStream,
114	P: LocalesProvider,
115	{
116	pub async fn prefetch_async(&mut self) {	×
117	let bundles = self.bundles();	×
118	bundles.prefetch_async().await;	×
119	}	×
120	}
121
122	impl<G, P> Localization<G, P>
123	where
124	G: BundleGenerator<LocalesIter = P::Iter>,
125	P: LocalesProvider,
126	{
127	pub fn bundles(&self) -> &Rc<Bundles<G>> {	11✔
128	self.bundles.get_or_init(\|\| {	11✔
129	Rc::new(Bundles::new(	11✔
130	self.sync,	11✔
131	self.res_ids.clone(),	11✔
132	&self.generator,	11✔
133	&self.provider,	11✔
134	))	11✔
135	})	11✔
136	}	11✔
137	}

projectfluent / fluent-rs / 13221860010

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous