@shexjs/writer

Utility functions to work with ShExJ schemas

install

npm install --save @shexjs/writer

Invocation

Using Partition(<schema>, [<URL>s]) as an example, an illustrative way to invoke from it from the command line uses @shexjs/parser and @shexjs/writer:

node -e 'const base = "http://a.example/"
  const schema = require("@shexjs/parser")
    .construct(base, {v: "http://a.example/vocab#"})
    .parse("<S1> { <p1> .; <p2> @<S2>? } <S2> { <p3> @<S3> } <S3> { <p4> @<S1> } <S4> { <p5> . }")
  const partition = require("@shexjs/util").partition(schema, [base + "S2"])
  new (require("@shexjs/writer"))({ base, simplifyParentheses: true })
    .writeSchema(partition,
      (error, text, prefixes) => {
        if (error)
          throw error;
        console.log(text);
      })'

The result is a ShExJ expression of the input schema:

BASE <http://a.example/>
<S2> {
  <p3> @<S3>
}
<S3> {
  <p4> @<S1>
}
<S1> {
    <p1> . ;
    <p2> @<S2>?
}

Note that <S2> in the input schema has no references to <S1>:

<S1> {
  <p1> .;
  <p2> @<S2>?
}
<S2> {
  <p3> @<S3>
}
<S3> {
  <p4> @<S1>
}
<S4> {
  <p5> .
}

ShExJtoAS(schema)

Parse a ShExJ schema and add ._prefixes and ._index for efficient processing within shexj.js

ShExAStoJ(schema)

Remove ._prefixes and ._index from internal schema structure and add schema["@context"] || "http://www.w3.org/ns/shex.jsonld"

ShExRVisitor:(knownShapeExprs), ShExRtoShExJ(schema-like-object)

Internal functions for parsing ShExR

canonicalize(schema, trimIRI)

Normalize ShExJ by moving all tripleExpression references to their first expression.

BiDiClosure

construct an object with this api:

needs: {} - mapping from needer to needie
neededBy: {} - reverse mapping of needs
add(needer, needie, negated) - record that needer referenced needied, possibly in a negation

nestShapes(schema, options = {})

See which shape declarations have no coreferences and can be nested inside their sole referrer.

options

no: don't do anything; just report nestable shapes
transform: function to change shape labels

getPredicateUsage(schema, untyped = {})

Return which predicates appear in which shapes, what their common type is, and whether they are polymorphic.

getDependencies(schema, ret)

Find which shappes depend on other shapes by inheritance or inclusion.

Partition(, [s])

Create subset of a schema with only desired shapes and their dependencies.

merge(left, right, overwrite, inPlace)

Merge right schema onto left schema if inPlace is true; otherwise return a new merged schema. overwrite: boolean specifies whether to replace and old shape declaration with a new one of the same name.

absolutizeResults(res, base)

In validation resutls with some relative URLs in it, re-evaluate all [shape, reference, node, subject, predicate, object] property values against base.

getProofGraph(res, db, dataFactory)

Parse a validation result and call db.addQuad() with each triple involved in validation.

Note, this may call db.addQuad() multiple times with the same triple if that triple appears more than once in the validation results.

isWellDefined(schema)

Verify that schema has all necessary referents and conforms to ShEx's stratified negation rules.

valuesToSchema(values)

Convert the results of validating an instance of ShExR against ShExR.shex into a ShExJ schema.

errsToSimple(failure)

Attempt to make a validation failure human-readable.

executeQuery(query, endpoint, dataFactory)

Synchronously Execute a SPARQL query against and endpoint.

executeQueryPromise(query, endpoint, dataFactory)

Asynchronously Execute a SPARQL query against and endpoint.

parseSparqlJsonResults (jsonObject)

Parse JSON results to internal RDF term representations.

parseSparqlXmlResults_dom(doc)

Parse XML results in a DOM to internal RDF term representations.

parseSparqlXmlResults_jquery(jqObj)

Parse XML results to internal RDF term representations using JQuery.

Lerna Monorepo

This repo uses lerna to manage multiple NPM packages. These packages are located in packages/*:

shape-map -- a ShapeMap parser
@shexjs/parser -- parse ShExC into ShExJ
@shexjs/writer -- serialize ShExK as ShExC
@shexjs/term -- RDF terms uses in ShEx
@shexjs/util -- some utilities for transforming schemas or validation output
@shexjs/visitor -- a visitor for schemas
@shexjs/validator -- validate nodes in an RDF graph against shapes in a schema
@shexjs/eval-validator-api -- API called by @shexjs/validator for validating Shapes, with tripleExpressions and EXTENDS etc.
@shexjs/eval-simple-1err -- Implementation of @shexjs/eval-validator-api which reports only one error.
@shexjs/eval-threaded-nerr -- Implementation of @shexjs/eval-validator-api which exhaustively enumerate combinations of ways the data fails to satisfy a shape's expression.
@shexjs/loader -- an API for loading and using ShEx schemas
@shexjs/node -- additional API functionality for a node environment
@shexjs/cli -- a set of command line tools for transformaing and validating with schemas
@shexjs/webapp -- the shex-simple WEBApp
@shexjs/shape-path-query -- traverse ShEx schemas with a path language
@shexjs/extension-test -- a small language for testing semantic actions in ShEx implementations (more)
@shexjs/extension-map -- an extension for transforming data from one schema to another (more)
@shexjs/extension-eval -- simple extension which evaluates Javascript semantic action code (more)

@shexjs/util