Crate oxirs_ttl 

OxiRS Turtle - RDF Format Parser

Status: Production Release (v0.2.2) 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 diff::compute_diff;

pub use diff::parse_patch;

pub use diff::RdfDiff;

pub use error::TurtleParseError;

pub use error::TurtleSyntaxError;

pub use incremental::IncrementalParser;

pub use incremental::ParseCheckpoint;

pub use incremental::ParseState;

pub use parser::NQuad;

pub use parser::NQuadsLiteParser;

pub use parser::NTriple;

pub use parser::NTriplesLiteParser;

pub use parser::ParseError as NtParseError;

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;

pub use writer::RdfTerm;

pub use writer::TermType;

pub use writer::TurtleWriter;

pub use writer::TurtleWriterConfig;

pub use patch::apply_patch;

pub use patch::diff_to_patch;

pub use patch::Graph;

pub use patch::PatchChange;

pub use patch::PatchError;

pub use patch::PatchHeader;

pub use patch::PatchParser;

pub use patch::PatchQuad;

pub use patch::PatchResult;

pub use patch::PatchSerializer;

pub use patch::PatchStats;

pub use patch::PatchTerm;

pub use patch::PatchTriple;

pub use patch::RdfPatch;

pub use mapping::DataSource;

pub use mapping::MappingEngine;

pub use mapping::MappingRule;

pub use mapping::MappingRuleBuilder;

pub use mapping::ObjectSpec;

pub use formats::jsonld::JsonLdContext;

pub use formats::jsonld::JsonLdError;

pub use formats::jsonld::JsonLdProcessor;

pub use formats::jsonld::JsonLdQuad;

pub use formats::jsonld::JsonLdResult;

pub use formats::jsonld::JsonLdTerm;

pub use formats::jsonld::JsonLdWriter;

pub use formats::jsonld::TermDefinition;

Modules

async_parserasync-tokio

Async I/O support for RDF parsing using Tokio

base_directive

@base / @prefix IRI resolution for Turtle/TriG (v1.1.0 round 6) @base / @prefix IRI resolution for Turtle and TriG.

compact_serializer

Compact Turtle serialization with subject/predicate grouping (v1.1.0 round 12) Compact Turtle serialization.

convenience

Convenience functions for common RDF parsing operations

diff

RDF graph diff and patch utilities

error

Error types for Turtle-family format parsing

formats

Format-specific parsers and serializers

incremental

Incremental parsing support for RDF formats

iri_catalog

IRI prefix catalog with CURIE expansion and compression (v1.1.0 round 13)

json_ld_framing

JSON-LD framing: apply a frame template to a node set (v1.1.0 round 11)

jsonld

JSON-LD 1.1 format parser, serializer, and processing algorithms

jsonld_compactor

JSON-LD compaction: converts expanded JSON-LD to compact form using a context (v1.1.0 round 15) JSON-LD compaction: converts expanded JSON-LD to compact form using a context.

lexer

Lexical analysis for Turtle-family formats

mapping

RML-inspired RDF Mapping Language support

n3

N3 format parser and reasoning (experimental)

namespace_mapper

Namespace/prefix management for Turtle and SPARQL serialization (v1.1.0 round 8) Namespace/prefix management for Turtle and SPARQL serialization.

nquads

N-Quads format parser and serializer

nt_parser

N-Triples and N-Quads streaming parser: IRI/blank-node/literal tokens, comment/blank line skip, typed literals, language tags, Unicode escapes (v1.1.0 round 14) N-Triples and N-Quads streaming parser (v1.1.0 round 14)

ntriples

N-Triples format parser and serializer

ntriples_writer

N-Triples/N-Quads serialization with proper escaping (v1.1.0 round 11) N-Triples and N-Quads serialization.

parallelparallel

Parallel processing support for RDF parsing using rayon

parser

Standalone RDF parsers operating on lightweight crate::writer::RdfTerm types

patch

RDF Patch Protocol implementation

prefix_resolver

Prefix/CURIE resolver for Turtle and TriG documents (v1.1.0 round 10)

pretty_printer

Turtle pretty printer with prefix analysis.

profiling

Performance profiling support for TTL parsing

rdf_thrift

RDF Binary (Thrift) format — read + write support

rdfa_parser

Basic RDFa 1.1 Lite parser: property/typeof/resource/about/prefix attributes, literal extraction, rel/rev links, context inheritance (v1.1.0 round 13) Basic RDFa 1.1 Lite parser.

streaming

Streaming support for memory-efficient parsing of large RDF files

streaming_parser

Incremental/streaming Turtle parser for large files (v1.1.0 round 7)

toolkit

Generic toolkit for building RDF parsers and serializers

trig

TriG format parser and serializer

trig_parser

TriG named-graph Turtle parser: @prefix/PREFIX declarations, GRAPH blocks, default-graph triples, prefix expansion, graph_sizes, named_graphs (v1.1.0 round 16) TriG named-graph Turtle parser (v1.1.0 round 16).

turtle

Turtle format parser and serializer

turtle_validator

Turtle/TriG document syntax validation (v1.1.0 round 9)

writer

Writer module: high-level Turtle serializer with prefix abbreviation