Crate oxirs_ttl 

OxiRS Turtle - RDF Format Parser

Status: Production Release (v0.1.0) Stability: Production-ready with 461 passing tests and 97% W3C compliance.

High-performance parsing and serialization for RDF formats in the Turtle family. Supports Turtle, TriG, N-Triples, N-Quads, and N3 with streaming and error recovery.

Ported from Oxigraph’s oxttl crate with adaptations for OxiRS.

Features

• Streaming support: Process large files with minimal memory usage
• Error recovery: Continue parsing despite syntax errors
• Async I/O: Optional Tokio async support
• Parallel processing: Process files in parallel chunks
• RDF 1.2 support: Quoted triples and directional language tags
• Incremental parsing: Parse as bytes arrive with checkpointing

Quick Start

Basic Turtle Parsing

use oxirs_ttl::{turtle::TurtleParser, Parser};
use std::io::Cursor;

let turtle_data = r#"
@prefix ex: <http://example.org/> .
ex:subject ex:predicate "object" .
"#;

let parser = TurtleParser::new();
for result in parser.for_reader(Cursor::new(turtle_data)) {
    let triple = result?;
    println!("{}", triple);
}

Error Recovery with Lenient Mode

use oxirs_ttl::turtle::TurtleParser;

let turtle_with_errors = r#"
@prefix ex: <http://example.org/> .
ex:good ex:pred "value" .
ex:also_good ex:pred "value2" .
"#;

// Lenient mode continues parsing after errors
let parser = TurtleParser::new_lenient();
let triples = parser.parse_document(turtle_with_errors)?;
println!("Parsed {} triples", triples.len());

Streaming Large Files

use oxirs_ttl::{StreamingParser, StreamingConfig};
use std::io::Cursor;

let config = StreamingConfig::default()
    .with_batch_size(10000);  // Process 10K triples per batch

let data = Cursor::new(b"<http://s> <http://p> <http://o> .");
let parser = StreamingParser::with_config(data, config);
let mut total = 0;

for batch in parser.batches() {
    let triples = batch?;
    total += triples.len();
    println!("Processed batch of {} triples", triples.len());
}
println!("Total: {} triples", total);

Incremental Parsing

use oxirs_ttl::{IncrementalParser, ParseState};

let mut parser = IncrementalParser::new();

// Feed data as it arrives
parser.push_data(b"@prefix ex: <http://example.org/> .\n")?;
parser.push_data(b"ex:s ex:p \"object\" .\n")?;
parser.push_eof();

// Parse available complete statements
let triples = parser.parse_available()?;
println!("Parsed {} triples", triples.len());

assert_eq!(parser.state(), ParseState::Complete);

Serialization with Pretty Printing

use oxirs_ttl::turtle::TurtleSerializer;
use oxirs_ttl::toolkit::{Serializer, SerializationConfig};
use oxirs_core::model::{NamedNode, Triple};

let triple = Triple::new(
    NamedNode::new("http://example.org/subject")?,
    NamedNode::new("http://example.org/predicate")?,
    NamedNode::new("http://example.org/object")?
);

// Create config with pretty printing
let config = SerializationConfig::default()
    .with_pretty(true)
    .with_use_prefixes(true);

let serializer = TurtleSerializer::with_config(config);

let mut output = Vec::new();
serializer.serialize(&vec![triple], &mut output)?;

let turtle_string = String::from_utf8(output)?;
println!("{}", turtle_string);

Re-exports

pub use error::TurtleParseError;

pub use error::TurtleSyntaxError;

pub use incremental::IncrementalParser;

pub use incremental::ParseCheckpoint;

pub use incremental::ParseState;

pub use profiling::ParsingStats;

pub use profiling::TtlProfiler;

pub use streaming::PrintProgress;

pub use streaming::ProgressCallback;

pub use streaming::StreamingConfig;

pub use streaming::StreamingParser;

pub use toolkit::Parser;

pub use toolkit::RuleRecognizer;

pub use toolkit::Serializer;

pub use toolkit::TokenRecognizer;

Modules

async_parserasync-tokio

Async I/O support for RDF parsing using Tokio

convenience

Convenience functions for common RDF parsing operations

error

Error types for Turtle-family format parsing

formats

Format-specific parsers and serializers

incremental

Incremental parsing support for RDF formats

lexer

Lexical analysis for Turtle-family formats

n3

N3 format parser and reasoning (experimental)

nquads

N-Quads format parser and serializer

ntriples

N-Triples format parser and serializer

parallelparallel

Parallel processing support for RDF parsing using rayon

profiling

Performance profiling support for TTL parsing

streaming

Streaming support for memory-efficient parsing of large RDF files

toolkit

Generic toolkit for building RDF parsers and serializers

trig

TriG format parser and serializer

turtle

Turtle format parser and serializer