Add toRDF events and tests.

- Add various toRDF relative reference events.
- Update test support.
- Add tests.

Author: davidlehn

lib/events.js

@@ -117,7 +117,13 @@ const _notSafeEventCodes = new Set([
   'relative @vocab reference',
   'reserved @id value',
   'reserved @reverse value',
-  'reserved term'
+  'reserved term',
+  // toRDF
+  'blank node predicate',
+  'relative graph reference',
+  'relative property reference',
+  'relative subject reference',
+  'relative type reference'
 ]);
 
 // safe handler that rejects unsafe warning conditions

lib/toRdf.js

@@ -10,6 +10,10 @@ const jsonCanonicalize = require('canonicalize');
 const types = require('./types');
 const util = require('./util');
 
+const {
+  handleEvent: _handleEvent
+} = require('./events');
+
 const {
   // RDF,
   // RDF_LIST,
@@ -66,6 +70,20 @@ api.toRDF = (input, options) => {
       graphTerm.value = graphName;
     } else {
       // skip relative IRIs (not valid RDF)
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'relative graph reference',
+            level: 'warning',
+            message: 'Relative graph reference found.',
+            details: {
+              graph: graphName
+            }
+          },
+          options
+        });
+      }
       continue;
     }
     _graphToRDF(dataset, nodeMap[graphName], graphTerm, issuer, options);
@@ -107,6 +125,20 @@ function _graphToRDF(dataset, graph, graphTerm, issuer, options) {
 
         // skip relative IRI subjects (not valid RDF)
         if(!_isAbsoluteIri(id)) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'relative subject reference',
+                level: 'warning',
+                message: 'Relative subject reference found.',
+                details: {
+                  subject: id
+                }
+              },
+              options
+            });
+          }
           continue;
         }
 
@@ -118,18 +150,48 @@ function _graphToRDF(dataset, graph, graphTerm, issuer, options) {
 
         // skip relative IRI predicates (not valid RDF)
         if(!_isAbsoluteIri(property)) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'relative property reference',
+                level: 'warning',
+                message: 'Relative property reference found.',
+                details: {
+                  property
+                }
+              },
+              options
+            });
+          }
           continue;
         }
 
         // skip blank node predicates unless producing generalized RDF
         if(predicate.termType === 'BlankNode' &&
           !options.produceGeneralizedRdf) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'blank node predicate',
+                level: 'warning',
+                message: 'Dropping blank node predicate.',
+                details: {
+                  // FIXME: add better issuer API to get reverse mapping
+                  property: issuer.getOldIds()
+                    .find(key => issuer.getId(key) === property)
+                }
+              },
+              options
+            });
+          }
           continue;
         }
 
         // convert list, value or node object to triple
-        const object =
-          _objectToRDF(item, issuer, dataset, graphTerm, options.rdfDirection);
+        const object = _objectToRDF(
+          item, issuer, dataset, graphTerm, options.rdfDirection, options);
         // skip null objects (they are relative IRIs)
         if(object) {
           dataset.push({
@@ -152,10 +214,11 @@ function _graphToRDF(dataset, graph, graphTerm, issuer, options) {
  * @param issuer a IdentifierIssuer for assigning blank node names.
  * @param dataset the array of quads to append to.
  * @param graphTerm the graph term for each quad.
+ * @param options the RDF serialization options.
  *
  * @return the head of the list.
  */
-function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection) {
+function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection, options) {
   const first = {termType: 'NamedNode', value: RDF_FIRST};
   const rest = {termType: 'NamedNode', value: RDF_REST};
   const nil = {termType: 'NamedNode', value: RDF_NIL};
@@ -166,7 +229,8 @@ function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection) {
   let subject = result;
 
   for(const item of list) {
-    const object = _objectToRDF(item, issuer, dataset, graphTerm, rdfDirection);
+    const object = _objectToRDF(
+      item, issuer, dataset, graphTerm, rdfDirection, options);
     const next = {termType: 'BlankNode', value: issuer.getId()};
     dataset.push({
       subject,
@@ -185,7 +249,8 @@ function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection) {
 
   // Tail of list
   if(last) {
-    const object = _objectToRDF(last, issuer, dataset, graphTerm, rdfDirection);
+    const object = _objectToRDF(
+      last, issuer, dataset, graphTerm, rdfDirection, options);
     dataset.push({
       subject,
       predicate: first,
@@ -211,10 +276,13 @@ function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection) {
  * @param issuer a IdentifierIssuer for assigning blank node names.
  * @param dataset the dataset to append RDF quads to.
  * @param graphTerm the graph term for each quad.
+ * @param options the RDF serialization options.
  *
  * @return the RDF literal or RDF resource.
  */
-function _objectToRDF(item, issuer, dataset, graphTerm, rdfDirection) {
+function _objectToRDF(
+  item, issuer, dataset, graphTerm, rdfDirection, options
+) {
   const object = {};
 
   // convert value object to RDF
@@ -260,8 +328,8 @@ function _objectToRDF(item, issuer, dataset, graphTerm, rdfDirection) {
       object.datatype.value = datatype || XSD_STRING;
     }
   } else if(graphTypes.isList(item)) {
-    const _list =
-      _listToRDF(item['@list'], issuer, dataset, graphTerm, rdfDirection);
+    const _list = _listToRDF(
+      item['@list'], issuer, dataset, graphTerm, rdfDirection, options);
     object.termType = _list.termType;
     object.value = _list.value;
   } else {
@@ -273,6 +341,20 @@ function _objectToRDF(item, issuer, dataset, graphTerm, rdfDirection) {
 
   // skip relative IRIs, not valid RDF
   if(object.termType === 'NamedNode' && !_isAbsoluteIri(object.value)) {
+    if(options.eventHandler) {
+      _handleEvent({
+        event: {
+          type: ['JsonLdEvent'],
+          code: 'relative type reference',
+          level: 'warning',
+          message: 'Relative type reference found.',
+          details: {
+            type: object.value
+          }
+        },
+        options
+      });
+    }
     return null;
   }