trinja 0.7.1

HTML templating / SSG for RDF(S) resources
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

use std::sync::Arc;

use minijinja::{State, Value, value::Object};
use taganak_core::graphs::Graph;
use taganak_framework::prelude::TryStreamExt;
use taganak_orm::re::{GraphView, Term};
use tokio::runtime::Handle;
use tracing::trace;

use crate::{
    ParamsWithEnv,
    res::{object::TermList, str_to_term},
};

#[derive(Debug, Clone)]
pub struct GraphFn<'e, G> {
    params: ParamsWithEnv<'e, G>,
}

impl<'e, G> GraphFn<'e, G>
where
    G: Graph + std::fmt::Debug + Sync + 'static,
{
    pub fn new(params: ParamsWithEnv<'e, G>) -> Self {
        Self { params }
    }
}

impl<G> Object for GraphFn<'_, G>
where
    G: Graph + std::fmt::Debug + Sync + 'static,
    Self: 'static,
{
    fn call(
        self: &Arc<Self>,
        _state: &State<'_, '_>,
        args: &[Value],
    ) -> Result<Value, minijinja::Error> {
        if args.len() < 2 {
            return Err(minijinja::Error::new(
                minijinja::ErrorKind::MissingArgument,
                "needs predicate and object",
            ));
        }

        if args.len() > 2 {
            return Err(minijinja::Error::new(
                minijinja::ErrorKind::TooManyArguments,
                "too many arguments",
            ));
        }

        let handle = Handle::current();

        handle.block_on(async {
            let subject = if args[0].is_none() {
                None
            } else {
                Some(str_to_term(self.params.clone().to_params(), &args[0].to_string()).unwrap())
            };

            let predicate = if args[1].is_none() {
                None
            } else {
                Some(str_to_term(self.params.clone().to_params(), &args[1].to_string()).unwrap())
            };

            trace!(?subject, ?predicate, "finding matching subjects");

            let graph = self.params.graph.read().unwrap();
            let view = graph.view().await;
            static LIMIT: usize = 256;
            let objects = view
                .objects(subject.as_ref(), predicate.as_ref(), Some(LIMIT))
                .await
                .unwrap()
                .try_collect::<Vec<Arc<Term>>>()
                .await
                .unwrap();

            Ok(Value::from_object(TermList::new(
                self.params.clone(),
                objects,
            )))
        })
    }
}