localize 0.2.0

Localization library
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use std::{collections::HashMap, borrow::Cow, fs};
use crate::{Locale, Sources, LocaleError};

#[derive(Debug, Default)]
pub(crate) struct LocaleCache<'a>(
    HashMap<
        &'a str, Locale
    >,
    pub(crate) Option<&'static str>
);

impl<'a> LocaleCache<'a> {
    pub fn new() -> Self {
        Default::default()
    }

    #[allow(unused)]
    pub fn look_up(&self, tag: &str) -> crate::Result<&Locale> {
        if let Some(locale) = self.0.get(tag) {
            return Ok(locale);
        } else {
            if let Some(default_tag) = self.1 {
                return self.0.get(default_tag).ok_or(LocaleError::CacheExhaustion);
            }
        }

        Err(LocaleError::CacheExhaustion)
    }
    
    #[allow(unused)]
    pub fn look_up_or_fetch(&self, tag: &str, sources: &Sources) -> crate::Result<Cow<Locale>> {
        if let Some(locale) = self.0.get(tag) {
            log::trace!("Locale `{}` was found in cache.", tag);

            Ok(Cow::Borrowed(locale))
        } else if let Some(path) = sources.get(tag) {
            log::trace!("Locale `{}` is missing in cache, fetching sources.", tag);

            let locale = json::from_reader(fs::File::open(path)?)?;
            log::trace!("Loaded locale `{}` from disk.", tag);
            Ok(Cow::Owned(locale))
        } else {

            if let Some(default_tag) = self.1 {
                log::trace!("Locale `{}` is missing in cache. Falling back to default locale `{}`.", tag, default_tag);

                if let Some(default) = self.0.get(default_tag) {
                    log::trace!("Fetched default locale `{}` from cache.", default_tag);

                    Ok(Cow::Borrowed(default))
                } else if let Some(path) = sources.get(default_tag) {
                    let default = json::from_reader(fs::File::open(path)?)?;
                    log::trace!("Fetched default locale `{}` from disk.", default_tag);
                    
                    Ok(Cow::Owned(default))
                } else {
                    log::error!("Fallback to default locale failed. Was not found in cache nor on disk.");

                    Err(LocaleError::FallbackToDefaultFailed)
                }

            } else {
                log::error!("Locale `{}` wasn't found in sources, and default was `None`. Aborted.", tag);
    
                Err(LocaleError::LocaleNotFound)
            }
        }
    }

    #[allow(unused, clippy::cast_ref_to_mut)]
    pub fn look_up_or_cache<'w>(&mut self, tag: &'w str, sources: &Sources) -> crate::Result<&Locale> 
    where
        'w: 'a
    {
        if let Some(locale) = self.0.get(tag) {
            log::trace!("Locale `{}` was found in cache.", tag);

            Ok(locale)
        } else if let Some(path) = sources.get(tag) {
            log::trace!("Locale `{}` is missing in cache, fetching sources.", tag);

            let locale = json::from_reader(fs::File::open(path)?)?;
            log::trace!("Loaded locale `{}` from disk.", tag);
            // let key: &'a str = unsafe { transmute(sources.keys().find(|&key| key == tag).unwrap().as_str()) };

            // Mm should be fine because it's other branch, at least I hope so.
            unsafe { &mut *(self as *const Self as *mut Self) }.0.insert(tag, locale);
            log::trace!("Overwritten locale `{}` in cache.", tag);
            Ok(self.0.get(tag).unwrap())

        } else {
            if let Some(default_tag) = self.1 {
                log::trace!("Locale `{}` is missing in cache. Falling back to default locale `{}`.", tag, default_tag);

                if let Some(default) = self.0.get(default_tag) {
                    Ok(default)
                } else if let Some(path) = sources.get(default_tag) {
                    let default = json::from_reader(fs::File::open(path)?)?;

                    unsafe { &mut *(self as *const Self as *mut Self) }.0.insert(default_tag, default);
                    log::trace!("Cached default locale `{}`.", default_tag);
                    Ok(self.0.get(default_tag).unwrap())
                } else {
                    log::error!("Fallback to default locale failed. Was not found in cache nor on disk.");

                    Err(LocaleError::FallbackToDefaultFailed)
                }
            } else {
                log::error!("Locale `{}` wasn't found in sources, and default was `None`. Aborted.", tag);
        
                Err(LocaleError::LocaleNotFound)
            }
        }
    }

    #[allow(unused)]
    pub fn prefer_recache<'w>(&mut self, tag: &'w str, sources: &Sources) -> crate::Result<&Locale> 
    where
        'w: 'a
    {
        if let Some(path) = sources.get(tag) {
            log::trace!("Locale `{}` was found in cache.", tag);

            let locale = json::from_reader(fs::File::open(path)?)?;
            self.0.insert(tag, locale);
            Ok(self.0.get(tag).unwrap())

        } else if let Some(default_tag) = self.1 {
            log::trace!("Locale `{}` is missing in cache. Falling back to default locale `{}`", tag, default_tag);

            let locale = json::from_reader(
                fs::File::open(
                    sources.get(default_tag).ok_or(LocaleError::SourceLookupFailed)?
                )?
            )?;
            self.0.insert(tag, locale);
            Ok(self.0.get(tag).unwrap())

        } else {
            self.look_up(tag)
        }
    }
}