core library

RDF (Resource Description Framework) Library for Dart

This library provides a comprehensive implementation of the W3C RDF data model, allowing applications to parse, manipulate, and serialize RDF data in various ways.

It implements the RDF 1.1 Concepts and Abstract Syntax specification and supports multiple serialization formats.

Core Concepts

RDF Data Model

RDF (Resource Description Framework) represents information as a graph of statements called "triples". Each triple consists of three parts:

• Subject: The resource being described (an IRI or blank node)
• Predicate: The property or relationship type (always an IRI)
• Object: The property value or related resource (an IRI, blank node, or literal)

Key Components

• IRIs: Internationalized Resource Identifiers that uniquely identify resources
• Blank Nodes: Anonymous resources without global identifiers
• Literals: Values like strings, numbers, or dates (optionally with language tags or datatypes)
• Triples: Individual statements in the form subject-predicate-object
• Graphs: Collections of triples representing related statements
• Quads: Triples with an additional graph context component
• Datasets: Collections containing a default graph and zero or more named graphs

Serialization Codecs

This library supports these RDF serialization codecs:

For RDF Graphs:

• Turtle: A compact, human-friendly text format (MIME type: text/turtle)
• N-Triples: A line-based, plain text format for encoding RDF graphs (MIME type: application/n-triples)

For RDF Datasets:

• TriG: Turtle-based format with named graph support (MIME type: application/trig)
• N-Quads: A line-based format for RDF datasets with named graph support (MIME type: application/n-quads)

Additional codecs are available as separate packages:

• JSON-LD: See locorda_rdf_jsonld
• RDF/XML: See locorda_rdf_xml
• Jelly: See locorda_rdf_jelly

The library uses a plugin system to allow registration of additional codecs.

Usage Examples

Basic Decoding and Encoding

// Create an RDF library instance with standard formats
final rdf = RdfCore.withStandardCodecs();

// Decode Turtle data
final turtleData = '''
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

<http://example.org/john> foaf:name "John Smith" ;
                           foaf:knows <http://example.org/jane> .
''';

final graph = rdf.decode(turtleData, contentType: 'text/turtle');

// Encode to N-Triples
final ntriples = rdf.encode(graph, contentType: 'application/n-triples');
print(ntriples);

Creating and Manipulating Graphs

// Create an empty graph
final graph = RdfGraph();

// Create terms
final subject = const IriTerm('http://example.org/john');
final predicate = const IriTerm('http://xmlns.com/foaf/0.1/name');
final object = LiteralTerm.string('John Smith');

// Add a triple
final newGraph = graph.withTriple(Triple(subject, predicate, object));

// Query the graph
final nameTriples = graph.getObjects(
  subject,
  predicate
);

// Print all objects for the given subject and predicate
for (final triple in nameTriples) {
  print('Name: ${triple.object}');
}

Working with RDF Datasets

// Create quads with graph context
final alice = IriTerm('http://example.org/alice');
final bob = IriTerm('http://example.org/bob');
final foafName = IriTerm('http://xmlns.com/foaf/0.1/name');
final foafKnows = IriTerm('http://xmlns.com/foaf/0.1/knows');
final peopleGraph = IriTerm('http://example.org/graphs/people');

final quads = [
  Quad(alice, foafName, LiteralTerm.string('Alice')), // default graph
  Quad(alice, foafKnows, bob, peopleGraph), // named graph
];

// Create dataset from quads
final dataset = RdfDataset.fromQuads(quads);

// Encode dataset to N-Quads format
final nquadsData = rdf.encodeDataset(dataset, contentType: 'application/n-quads');

// Decode N-Quads data
final decodedDataset = rdf.decodeDataset(nquadsData, contentType: 'application/n-quads');

Auto-detection of codecs

// The library can automatically detect the codec from content
final unknownContent = getContentFromSomewhere();
final graph = rdf.decode(unknownContent); // Format auto-detected

Using Custom Prefixes in Serialization

Note that this is rarely needed, as the library knows some well-known prefixes and will automatically generate missing prefixes for you. However, this gives you more control over the output.

final customPrefixes = {
  'example': 'http://example.org/',
  'foaf': 'http://xmlns.com/foaf/0.1/'
};

final turtle = rdf.encode(
  graph,
  contentType: 'text/turtle',
  options: TurtleEncoderOptions(
    customPrefixes: customPrefixes
  )
);

Architecture

The library follows a modular design with these key components:

• Terms: Classes for representing RDF terms (IRIs, blank nodes, literals)
• Triples: The atomic data unit in RDF, combining subject, predicate, and object
• Graphs: Collections of triples with query capabilities
• Decoders: Convert serialized RDF text into graph structures
• Encoders: Convert graph structures into serialized text
• Codec Registry: Plugin system for registering new codecs

The design follows IoC principles with dependency injection, making the library highly testable and extensible.