annatto 0.53.0

Converts linguistic data formats based on the graphANNIS data model as intermediate representation and can apply consistency tests.
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

use std::borrow::Cow;

use graphannis::{AnnotationGraph, aql};
use graphannis_core::errors::GraphAnnisCoreError;
use lazy_static::lazy_static;
use serde::{Deserialize, Deserializer};

use crate::error::AnnattoError;

lazy_static! {
    static ref empty_graph: Result<AnnotationGraph, GraphAnnisCoreError> =
        AnnotationGraph::new(false);
}

pub(crate) fn deserialize_and_check<'de, D: Deserializer<'de>>(
    deserializer: D,
) -> Result<String, D::Error> {
    let query = Cow::<str>::deserialize(deserializer)?;
    check_deserialized_query(&query).map_err(serde::de::Error::custom)?;
    Ok(query.to_string())
}

pub(crate) fn check_deserialized_query(query: &str) -> Result<(), AnnattoError> {
    // checks syntax
    let dj = aql::parse(query, false).map_err(AnnattoError::InvalidQuery)?;
    // checks semantics
    if let Ok(graph) = &*empty_graph {
        aql::execute_query_on_graph(graph, &dj, true, None)
            .map_err(AnnattoError::InvalidQuery)?
            .next();
    }
    Ok(())
}

pub(crate) mod in_sequence {
    use super::*;

    pub(crate) fn deserialize_and_check<'de, D: Deserializer<'de>, T: FromIterator<String>>(
        deserializer: D,
    ) -> Result<T, D::Error> {
        let queries = Vec::<String>::deserialize(deserializer)?;
        queries
            .iter()
            .enumerate()
            .try_for_each(|(i, query)| {
                check_deserialized_query(query).map_err(|e| match e.with_index(i as u16 + 1u16) {
                    Ok(e) => e,
                    Err(e) => e,
                })
            })
            .map_err(serde::de::Error::custom)?;
        Ok(queries.into_iter().collect())
    }
}

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;

    use super::*;

    #[derive(Deserialize)]
    struct QueryHolder {
        #[serde(deserialize_with = "crate::estarde::query::deserialize_and_check")]
        query: String,
    }

    #[test]
    fn fails() {
        let probe: Result<QueryHolder, _> = toml::from_str("query = 'annis:tok'");
        assert!(probe.is_err());
        assert_snapshot!(probe.err().unwrap());
    }

    #[test]
    fn passes() {
        let probe: Result<QueryHolder, _> = toml::from_str("query = 'tok'");
        assert!(probe.is_ok());
        assert_snapshot!(probe.unwrap().query)
    }
}