shacl-compact-syntax

name	shacl-compact-syntax
description	Parse or write SHACL Compact Syntax (SHACL-C/SCS) shapes with the opt-in sparq-shaclc Rust crate. Use when converting strict W3C CG syntax or shaclc-js extended syntax to oxrdf triples, building a sparq-shacl validation graph, handling typed source errors, using the generated streaming parser, or faithfully serialising an expressible shapes graph back to compact syntax.

SHACL Compact Syntax

Use sparq-shaclc as a separate opt-in parser/writer crate. Its crate-root API emits oxrdf::Triple values; add sparq-shacl only when the resulting shapes must be validated against data.

Parse shapes

Cargo.toml:

[dependencies]
sparq-core = { path = "../sparq-core" }
sparq-shaclc = { path = "../sparq-shaclc" }
sparq-shacl = { path = "../sparq-shacl" } # only for validation/Graph conversion

Parse strict SHACL-C and turn the triples into a validation-ready shapes graph:

use sparq_core::Graph;
use sparq_shaclc::{parse_strict, DEFAULT_BASE};

let source = r#"
PREFIX ex: <http://example.org/>
shape ex:PersonShape -> ex:Person {
  ex:name [1..1] xsd:string .
}
"#;

let (triples, outcome) = parse_strict(source, DEFAULT_BASE)?;
let shapes = sparq_shacl::graph_from_triples(triples);
let data = Graph::load_str("@prefix ex: <http://example.org/> . ex:a a ex:Person .", "turtle")
    .expect("valid Turtle data");
let report = sparq_shacl::validate(&data, &shapes);
assert!(!report.conforms);
assert_eq!(outcome.base, DEFAULT_BASE);
# Ok::<(), Box<dyn std::error::Error>>(())

Relative IRIs resolve against the base argument. A document BASE directive overrides that argument for following IRIs. Outcome returns the final base and prefixes in declaration order, with rdf, rdfs, sh, xsd, and owl first.

Choose a profile

Use the explicit dispatcher when the input profile is selected at runtime:

use sparq_shaclc::{parse, Profile, DEFAULT_BASE};

let profile = Profile::Extended;
let (triples, outcome) = parse(source, DEFAULT_BASE, profile)?;
# Ok::<(), sparq_shaclc::ShaclcError>(())

• Profile::Strict / parse_strict accepts the W3C Community Group surface plus the RDF 1.2 layer supported by the crate.
• Profile::Extended / parse_extended additionally accepts shaclc-js extensions such as annotation lists, % ... % property escapes, trailing Turtle statements, and the a keyword.
• Do not use extended mode as a fallback for input that must be strict; strict mode rejects those extensions by construction.

ShaclcError exposes 1-based line and byte-counted column, an optional stable code such as UNDECLARED_PREFIX, and a human-readable message.

Write compact syntax

Pass the parse outcome back to the residual-consumption writer:

use sparq_shaclc::{write, Profile};

let compact = write(
    &triples,
    Some(&outcome.base),
    &outcome.prefixes,
    Profile::Strict,
)?;
# Ok::<(), sparq_shaclc::ShaclcWriteError>(())

Writing is all-or-nothing. ShaclcWriteError::residual contains exact triples that the selected profile cannot express; missing_ontology identifies a graph without the required ontology subject. Never treat the error as partial output.

Stream generated terms

Use sparq_shaclc::raw::shaclc12 or raw::shaclc12ext only when callback or chunked push parsing is required. These modules expose their generated term model, parse, and PushParser; the crate-root functions are preferable when the consumer needs oxrdf::Triple values.

Keep SHACL validation concerns in the shacl-validation skill. This crate parses and writes shapes; it does not validate data itself.