otter 1.2.1

Otter game system; main data structures Rust crate.
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

// Copyright 2020-2021 Ian Jackson and contributors to Otter
// SPDX-License-Identifier: AGPL-3.0-or-later
// There is NO WARRANTY.

use crate::prelude::*;

use parking_lot::MappedRwLockReadGuard;
use parking_lot::{const_rwlock, RwLock, RwLockReadGuard};

static STATE: RwLock<Option<State>> = const_rwlock(None);

struct State {
  tera: Tera,
}

#[throws(StartupError)]
pub fn init_from_config() {
  init_from_dir(&config().nwtemplate_dir)?;
}

#[throws(StartupError)]
pub fn init_from_dir(nwtemplate_dir: &str) {
  let mut guard = STATE.write();
  assert!(guard.is_none());
  let glob = format!("{}/*.tera", nwtemplate_dir);
  let tera = Tera::new(&glob)
    .map_err(|e| anyhow!("{}", e))
    .context("load tamplates")
    .with_context(|| nwtemplate_dir.to_string())?;

  if tera.get_template_names().next().is_none() {
    warn!("nwtemplates directory {:?} contains no templates!",
          nwtemplate_dir);
  }

  *guard = Some(State {
    tera,
  })
}

#[throws(anyhow::Error)]
pub fn render<D>(template_name: &str, data: &D) -> String
where D: Serialize + Debug
{
  fn get_tera() -> MappedRwLockReadGuard<'static, Tera> {
    let g = STATE.read();
    RwLockReadGuard::map(g, |g| &g.as_ref().unwrap().tera)
  }
  let context = tera::Context::from_serialize(data)
    .with_context(
      || format!("failed make context from serializable {:?}", data)
    )
    .map_err(IE::from)?;
  get_tera().render(template_name, &context).map_err(|e| {
    error!("template render error: {:?}", &e);
    anyhow!(e.to_string())
  })?
}