tortank 0.30.7

Turtle/N3 parser
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

use std::collections::VecDeque;

use nom_language::error::VerboseError;

use crate::prelude::*;

use crate::shared::RDF_NIL;

use crate::triple_common_parser::iri::iri;
use crate::triple_common_parser::literal::literal_turtle as literal;
use crate::triple_common_parser::prologue::{
    base_sparql, base_turtle, prefix_sparql, prefix_turtle,
};
use crate::triple_common_parser::triple::{
    anon_bnode, collection, labeled_bnode, ns_type, object_list, predicate_list,
};
use crate::triple_common_parser::{BlankNode, Iri, Literal, comments};

#[derive(PartialEq, Debug)]
pub enum TurtleValue<'a> {
    Base(Iri<'a>),
    Prefix((&'a str, Iri<'a>)),
    Iri(Iri<'a>),
    Literal(Literal<'a>),
    BNode(BlankNode<'a>),
    ObjectList(Vec<TurtleValue<'a>>),
    Collection(VecDeque<TurtleValue<'a>>),
    PredicateObject {
        predicate: Box<TurtleValue<'a>>,
        object: Box<TurtleValue<'a>>,
    },
    Statement {
        subject: Box<TurtleValue<'a>>,
        predicate_objects: Vec<TurtleValue<'a>>,
    },
}

fn object_lists(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    object_list(object, TurtleValue::ObjectList).parse(s)
}

fn predicate_lists<'a, F>(
    subject_extractor: F,
) -> impl Parser<&'a str, Output = TurtleValue<'a>, Error = VerboseError<&'a str>>
where
    F: Fn(&'a str) -> ParserResult<'a, TurtleValue<'a>>,
{
    let map_predicate_object = |(predicate, objects)| TurtleValue::PredicateObject {
        predicate: Box::new(predicate),
        object: Box::new(objects),
    };
    predicate_list(
        subject_extractor,
        predicate,
        object_lists,
        map_predicate_object,
        |subject, list| TurtleValue::Statement {
            subject: Box::new(subject),
            predicate_objects: list,
        },
    )
}

fn collection_turtle(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    map(collection(object), |res: VecDeque<TurtleValue>| {
        if res.is_empty() {
            TurtleValue::Iri(Iri::Enclosed(RDF_NIL))
        } else {
            TurtleValue::Collection(res)
        }
    })
    .parse(s)
}

fn anon_bnode_turtle(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    let unlabeled_subject = |s| Ok((s, TurtleValue::BNode(BlankNode::Unlabeled)));
    anon_bnode(alt((predicate_lists(unlabeled_subject), unlabeled_subject))).parse(s)
}

fn blank_node(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    alt((map(labeled_bnode, TurtleValue::BNode), anon_bnode_turtle)).parse(s)
}

fn iri_turtle(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    map(iri, TurtleValue::Iri).parse(s)
}
fn literal_turtle(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    map(literal, TurtleValue::Literal).parse(s)
}

pub(crate) fn subject(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    alt((blank_node, iri_turtle, collection_turtle)).parse(s)
}
pub(crate) fn predicate(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    alt((map(ns_type, TurtleValue::Iri), iri_turtle)).parse(s)
}

pub(crate) fn object(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    preceded(
        multispace0,
        alt((iri_turtle, blank_node, collection_turtle, literal_turtle)),
    )
    .parse(s)
}

pub(crate) fn triples(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    terminated(
        alt((predicate_lists(subject), anon_bnode_turtle)),
        preceded(multispace0, terminated(alt((tag("."), eof)), multispace0)),
    )
    .parse(s)
}

pub(crate) fn ntriple_statement(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    preceded(
        comments,
        terminated(
            map(
                (ntriple_subject, ntriple_predicate, ntriple_object),
                |(s, p, o)| TurtleValue::Statement {
                    subject: Box::new(s),
                    predicate_objects: vec![TurtleValue::PredicateObject {
                        predicate: Box::new(p),
                        object: Box::new(o),
                    }],
                },
            ),
            preceded(multispace0, terminated(alt((tag("."), eof)), multispace0)),
        ),
    )
    .parse(s)
}
pub(crate) fn ntriple_subject(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    alt((map(labeled_bnode, TurtleValue::BNode), iri_turtle)).parse(s)
}
pub(crate) fn ntriple_predicate(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    alt((map(ns_type, TurtleValue::Iri), iri_turtle)).parse(s)
}

pub(crate) fn ntriple_object(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    preceded(
        multispace0,
        alt((
            iri_turtle,
            map(labeled_bnode, TurtleValue::BNode),
            literal_turtle,
        )),
    )
    .parse(s)
}

fn directive(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    let base_to_turtle = map(alt((base_sparql, base_turtle)), TurtleValue::Base);
    let prefix_to_turtle = map(alt((prefix_turtle, prefix_sparql)), TurtleValue::Prefix);
    alt((base_to_turtle, prefix_to_turtle)).parse(s)
}

pub(crate) fn statement(s: &'_ str) -> ParserResult<'_, TurtleValue<'_>> {
    preceded(comments, alt((directive, triples))).parse(s)
}

pub fn statements(s: &'_ str) -> ParserResult<'_, Vec<TurtleValue<'_>>> {
    many0(statement).parse(s)
}