lang_turtle/ecs/
parse.rs

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
use bevy_ecs::prelude::*;
use chumsky::Parser;
use lsp_core::prelude::*;
use tracing::info;

use crate::{
    lang::{parser::parse_turtle, tokenizer::parse_tokens},
    TurtleLang,
};

// #[instrument(skip(query, commands), name = "parse_source")]
pub fn parse_source(
    query: Query<(Entity, &Source), (Changed<Source>, With<TurtleLang>)>,
    mut commands: Commands,
) {
    for (entity, source) in &query {
        let (tok, es) = parse_tokens().parse_recovery(source.0.as_str());
        if let Some(tokens) = tok {
            let t = Tokens(tokens);
            commands.entity(entity).insert(t);
        }
        commands.entity(entity).insert(Errors(es));
    }
}

// #[instrument(skip(query, commands), name = "parse_turtle")]
pub fn parse_turtle_system(
    query: Query<(Entity, &Source, &Tokens, &Label), (Changed<Tokens>, With<TurtleLang>)>,
    mut commands: Commands,
) {
    for (entity, source, tokens, label) in &query {
        let (turtle, es) = parse_turtle(&label.0, tokens.0.clone(), source.0.len());
        info!(
            "{} triples ({} errors)",
            turtle.value().triples.len(),
            es.len()
        );
        if es.is_empty() {
            let element = Element::<TurtleLang>(turtle);
            commands
                .entity(entity)
                .insert((element, Errors(es)))
                .remove::<Dirty>();
        } else {
            let element = Element::<TurtleLang>(turtle);
            commands.entity(entity).insert((Errors(es), element, Dirty));
        }
    }
}

// #[instrument(skip(query, commands), name = "derive_triples")]
pub fn derive_triples(
    query: Query<(Entity, &Element<TurtleLang>), (Changed<Element<TurtleLang>>, With<TurtleLang>)>,
    mut commands: Commands,
) {
    for (entity, turtle) in &query {
        if let Ok(tripl) = turtle.0.get_simple_triples() {
            let triples: Vec<_> = tripl.iter().map(|x| x.to_owned()).collect();
            commands.entity(entity).insert(Triples(triples));
        }
    }
}