Support recursive scoped contexts.

- Support 1.0 recursion error code.
- Support 1.1 "context overflow" error code.
- Allow recursion in scoped contexts.

Author: davidlehn

lib/ContextResolver.js

@@ -28,7 +28,9 @@ module.exports = class ContextResolver {
     this.sharedCache = sharedCache;
   }
 
-  async resolve({context, documentLoader, base, cycles = new Set()}) {
+  async resolve({
+    activeCtx, context, documentLoader, base, cycles = new Set()
+  }) {
     // process `@context`
     if(context && _isObject(context) && context['@context']) {
       context = context['@context'];
@@ -46,7 +48,7 @@ module.exports = class ContextResolver {
         if(!resolved) {
           // not resolved yet, resolve
           resolved = await this._resolveRemoteContext(
-            {url: ctx, documentLoader, base, cycles});
+            {activeCtx, url: ctx, documentLoader, base, cycles});
         }
 
         // add to output and continue
@@ -109,38 +111,49 @@ module.exports = class ContextResolver {
     return resolved;
   }
 
-  async _resolveRemoteContext({url, documentLoader, base, cycles}) {
+  async _resolveRemoteContext({activeCtx, url, documentLoader, base, cycles}) {
     // resolve relative URL and fetch context
     url = prependBase(base, url);
     const {context, remoteDoc} = await this._fetchContext(
-      {url, documentLoader, cycles});
+      {activeCtx, url, documentLoader, cycles});
 
     // update base according to remote document and resolve any relative URLs
     base = remoteDoc.documentUrl || url;
     _resolveContextUrls({context, base});
 
     // resolve, cache, and return context
     const resolved = await this.resolve(
-      {context, documentLoader, base, cycles});
+      {activeCtx, context, documentLoader, base, cycles});
     this._cacheResolvedContext({key: url, resolved, tag: remoteDoc.tag});
     return resolved;
   }
 
-  async _fetchContext({url, documentLoader, cycles}) {
+  async _fetchContext({activeCtx, url, documentLoader, cycles}) {
     // check for max context URLs fetched during a resolve operation
     if(cycles.size > MAX_CONTEXT_URLS) {
       throw new JsonLdError(
         'Maximum number of @context URLs exceeded.',
         'jsonld.ContextUrlError',
-        {code: 'loading remote context failed', max: MAX_CONTEXT_URLS});
+        {
+          code: activeCtx.processingMode === 'json-ld-1.0' ?
+            'loading remote context failed' :
+            'context overflow',
+          max: MAX_CONTEXT_URLS
+        });
     }
 
     // check for context URL cycle
+    // shortcut to avoid extra work that would eventually hit the max above
     if(cycles.has(url)) {
       throw new JsonLdError(
         'Cyclical @context URLs detected.',
         'jsonld.ContextUrlError',
-        {code: 'recursive context inclusion', url});
+        {
+          code: activeCtx.processingMode === 'json-ld-1.0' ?
+            'recursive context inclusion' :
+            'context overflow',
+          url
+        });
     }
 
     // track cycles

lib/context.js

@@ -47,7 +47,8 @@ module.exports = api;
 api.process = async ({
   activeCtx, localCtx, options,
   propagate = true,
-  overrideProtected = false
+  overrideProtected = false,
+  cycles = new Set()
 }) => {
   // normalize local context to an array of @context objects
   if(_isObject(localCtx) && '@context' in localCtx &&
@@ -63,6 +64,7 @@ api.process = async ({
 
   // resolve contexts
   const resolved = await options.contextResolver.resolve({
+    activeCtx,
     context: localCtx,
     documentLoader: options.documentLoader,
     base: options.base
@@ -310,6 +312,7 @@ api.process = async ({
 
       // resolve contexts
       const resolvedImport = await options.contextResolver.resolve({
+        activeCtx,
         context: value,
         documentLoader: options.documentLoader,
         base: options.base
@@ -355,23 +358,37 @@ api.process = async ({
       });
 
       if(_isObject(ctx[key]) && '@context' in ctx[key]) {
+        const keyCtx = ctx[key]['@context'];
+        let process = true;
+        if(_isString(keyCtx)) {
+          const url = prependBase(options.base, keyCtx);
+          // track processed contexts to avoid scoped context recursion
+          if(cycles.has(url)) {
+            process = false;
+          } else {
+            cycles.add(url);
+          }
+        }
         // parse context to validate
-        try {
-          await api.process({
-            activeCtx: rval,
-            localCtx: ctx[key]['@context'],
-            overrideProtected: true,
-            options
-          });
-        } catch(e) {
-          throw new JsonLdError(
-            'Invalid JSON-LD syntax; invalid scoped context.',
-            'jsonld.SyntaxError',
-            {
-              code: 'invalid scoped context',
-              context: ctx[key]['@context'],
-              term: key
+        if(process) {
+          try {
+            await api.process({
+              activeCtx: rval,
+              localCtx: ctx[key]['@context'],
+              overrideProtected: true,
+              options,
+              cycles
             });
+          } catch(e) {
+            throw new JsonLdError(
+              'Invalid JSON-LD syntax; invalid scoped context.',
+              'jsonld.SyntaxError',
+              {
+                code: 'invalid scoped context',
+                context: ctx[key]['@context'],
+                term: key
+              });
+          }
         }
       }
     }