Crate turtle_syntax

Expand description

Turtle is a textual syntax for RDF that allows an RDF graph to be completely written in a compact and natural text form, with abbreviations for common usage patterns and datatypes. This library provides a Turtle parser for Rust that keeps tracks of code mapping metadata for each syntax node using the locspan library.

§Basic usage

Elements of the Turtle abstract syntax tree (implementing Parsable) are parsed using a Token iterator (a.k.a a lexer). A Lexer can be created from a char iterator. We can then use the Document::parse function to parse a Turtle document from the lexer. In the following example, we use the excellent codespan_reporting crate to report errors.

use codespan_reporting::diagnostic::{Diagnostic, Label};
use codespan_reporting::files::SimpleFiles;
use codespan_reporting::term::termcolor::{ColorChoice, StandardStream};
use locspan::Meta;
use std::fs::File;
use std::io::Read;
use turtle_syntax::{
  parsing::Parse,
  Document,
};

fn main() -> std::io::Result<()> {
  let mut args = std::env::args();
  args.next();

  let mut files = SimpleFiles::new();

  for filename in args {
    let mut file = File::open(&filename)?;
    let mut buffer = String::new();
    file.read_to_string(&mut buffer)?;
    let file_id = files.add(filename.clone(), buffer);
    let buffer = files.get(file_id).unwrap();

    match Document::parse_str(buffer.source().as_str(), |span| span) {
      Ok(_doc) => {
        // do something
      }
      Err(Meta(e, span)) => {
        let diagnostic = Diagnostic::error()
          .with_message(format!("parse error: {}", e))
          .with_labels(vec![Label::primary(file_id, span)]);

        let writer = StandardStream::stderr(ColorChoice::Auto);
        let config = codespan_reporting::term::Config::default();
        codespan_reporting::term::emit(&mut writer.lock(), &config, &files, &diagnostic)
          .unwrap();
      }
    }
  }

  Ok(())
}

The above code will have the following kind of output when a syntax error is detected:

error: parse error: unexpected character ` `
  ┌─ examples/syntax_error.ttl:5:34
  │
5 │ <http://www.w3.org/TR/rdf-syntax- grammar>
  │                                  ^

Re-exports§

pub use build::Build;
pub use lexing::Lexer;
pub use parsing::Parse;

Modules§

build
lexing
parsing

Structs§

BlankId: Blank node identifier.
BlankIdBuf: Owned blank node identifier.
Collection: Collection of objects.
DecimalBuf: Owned decimal number.
Document: A Turtle document.
DoubleBuf: Owned double number.
IntegerBuf: Owned integer number.
Objects: Non empty list of objects.
PredicateObjects
Triples

Enums§

BlankNode
Directive: A directive.
Iri: An IRI or compact IRI.
Literal: Literal value.
NumericLiteral: Numeric literal value.
Object: Object of a triples declaration.
Statement: A statement (directive of triples declaration).
Subject: Subject of a triples declaration.
Verb: Verb (either a or a predicate).

Type Aliases§

BlankNodePropertyList
PredicateObjectsList
RdfLiteral