Use events for language value warnings.

Author: davidlehn

lib/expand.js

@@ -39,6 +39,10 @@ const {
   validateTypeValue: _validateTypeValue
 } = require('./util');
 
+const {
+  handleEvent: _handleEvent
+} = require('./events');
+
 const api = {};
 module.exports = api;
 const REGEX_BCP47 = /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/;
@@ -591,9 +595,19 @@ async function _expandObject({
       value = _asArray(value).map(v => _isString(v) ? v.toLowerCase() : v);
 
       // ensure language tag matches BCP47
-      for(const lang of value) {
-        if(_isString(lang) && !lang.match(REGEX_BCP47)) {
-          console.warn(`@language must be valid BCP47: ${lang}`);
+      for(const language of value) {
+        if(_isString(language) && !language.match(REGEX_BCP47)) {
+          _handleEvent({
+            event: {
+              code: 'invalid @language value',
+              level: 'warning',
+              message: '@language value must be valid BCP47.',
+              details: {
+                language
+              }
+            },
+            options
+          });
         }
       }
 

lib/fromRdf.js

@@ -8,6 +8,10 @@ const graphTypes = require('./graphTypes');
 const types = require('./types');
 const util = require('./util');
 
+const {
+  handleEvent: _handleEvent
+} = require('./events');
+
 // constants
 const {
   // RDF,
@@ -44,15 +48,16 @@ module.exports = api;
  */
 api.fromRDF = async (
   dataset,
-  {
-    useRdfType = false,
-    useNativeTypes = false,
-    rdfDirection = null
-  }
+  options
 ) => {
   const defaultGraph = {};
   const graphMap = {'@default': defaultGraph};
   const referencedOnce = {};
+  const {
+    useRdfType = false,
+    useNativeTypes = false,
+    rdfDirection = null
+  } = options;
 
   for(const quad of dataset) {
     // TODO: change 'name' to 'graph'
@@ -87,7 +92,7 @@ api.fromRDF = async (
       continue;
     }
 
-    const value = _RDFToObject(o, useNativeTypes, rdfDirection);
+    const value = _RDFToObject(o, useNativeTypes, rdfDirection, options);
     util.addValue(node, p, value, {propertyIsArray: true});
 
     // object may be an RDF list/partial list node but we can't know easily
@@ -275,10 +280,12 @@ api.fromRDF = async (
  *
  * @param o the RDF triple object to convert.
  * @param useNativeTypes true to output native types, false not to.
+ * @param rdfDirection text direction mode [null, i18n-datatype]
+ * @param options top level API options
  *
  * @return the JSON-LD object.
  */
-function _RDFToObject(o, useNativeTypes, rdfDirection) {
+function _RDFToObject(o, useNativeTypes, rdfDirection, options) {
   // convert NamedNode/BlankNode object to JSON-LD
   if(o.termType.endsWith('Node')) {
     return {'@id': o.value};
@@ -335,7 +342,17 @@ function _RDFToObject(o, useNativeTypes, rdfDirection) {
       if(language.length > 0) {
         rval['@language'] = language;
         if(!language.match(REGEX_BCP47)) {
-          console.warn(`@language must be valid BCP47: ${language}`);
+          _handleEvent({
+            event: {
+              code: 'invalid @language value',
+              level: 'warning',
+              message: '@language value must be valid BCP47.',
+              details: {
+                language
+              }
+            },
+            options
+          });
         }
       }
       rval['@direction'] = direction;

lib/jsonld.js

@@ -600,6 +600,8 @@ jsonld.normalize = jsonld.canonize = async function(input, options) {
  *            (default: false).
  *          [useNativeTypes] true to convert XSD types into native types
  *            (boolean, integer, double), false not to (default: false).
+ *          [rdfDirection] 'i18n-datatype' to support RDF transformation of
+ *             @direction (default: null).
  *          [handleEvent] handler for events such as warnings.
  *
  * @return a Promise that resolves to the JSON-LD document.

tests/misc.js

@@ -651,4 +651,109 @@ describe('events', () => {
     assert.equal(ranHandler3, true, 'ran handler 3');
     assert.equal(handled, true, 'handled');
   });
+  it('handle known warning events', async () => {
+    const d =
+{
+  "@context": {
+    "id-at": {"@id": "@test"},
+    "@RESERVED": "ex:test"
+  },
+  "@RESERVED": "test",
+  "ex:language": {
+    "@value": "test",
+    "@language": "!"
+  }
+}
+;
+    const ex =
+[
+  {
+    "ex:language": [
+      {
+        "@value": "test",
+        "@language": "!"
+      }
+    ]
+  }
+]
+;
+
+    let handledReservedTerm = false;
+    let handledReservedValue = false;
+    let handledLanguage = false;
+    const e = await jsonld.expand(d, {
+      handleEvent: {
+        'invalid reserved term': () => {
+          handledReservedTerm = true;
+        },
+        'invalid reserved value': () => {
+          handledReservedValue = true;
+        },
+        'invalid @language value': () => {
+          handledLanguage = true;
+        }
+      }
+    });
+    assert.deepStrictEqual(e, ex);
+    assert.equal(handledReservedTerm, true);
+    assert.equal(handledReservedValue, true);
+    assert.equal(handledLanguage, true);
+
+    // dataset with invalid language tag
+    // Equivalent N-Quads:
+    // <ex:s> <ex:p> "..."^^<https://www.w3.org/ns/i18n#!_rtl> .'
+    // Using JSON dataset to bypass N-Quads parser checks.
+    const d2 =
+[
+  {
+    "subject": {
+      "termType": "NamedNode",
+      "value": "ex:s"
+    },
+    "predicate": {
+      "termType": "NamedNode",
+      "value": "ex:p"
+    },
+    "object": {
+      "termType": "Literal",
+      "value": "invalid @language value",
+      "datatype": {
+        "termType": "NamedNode",
+        "value": "https://www.w3.org/ns/i18n#!_rtl"
+      }
+    },
+    "graph": {
+      "termType": "DefaultGraph",
+      "value": ""
+    }
+  }
+]
+;
+    const ex2 =
+[
+  {
+    "@id": "ex:s",
+    "ex:p": [
+      {
+        "@value": "invalid @language value",
+        "@language": "!",
+        "@direction": "rtl"
+      }
+    ]
+  }
+]
+;
+
+    let handledLanguage2 = false;
+    const e2 = await jsonld.fromRDF(d2, {
+      rdfDirection: 'i18n-datatype',
+      handleEvent: {
+        'invalid @language value': () => {
+          handledLanguage2 = true;
+        }
+      }
+    });
+    assert.deepStrictEqual(e2, ex2);
+    assert.equal(handledLanguage2, true);
+  });
 });