Preserve previous context when processing type-scoped contexts.

Author: dlongley

lib/context.js

@@ -66,6 +66,21 @@ api.process = ({
     return activeCtx;
   }
 
+  // track the previous context
+  const previousContext = activeCtx;
+
+  // if context is property scoped and there's a previous context, amend it,
+  // not the current one
+  if(isPropertyTermScopedContext && activeCtx.previousContext) {
+    activeCtx.previousContext = api.process({
+      activeCtx: activeCtx.previousContext,
+      localCtx: ctxs,
+      options,
+      isPropertyTermScopedContext
+    });
+    return activeCtx;
+  }
+
   // process each context in order, update active context
   // on each iteration to ensure proper caching
   let rval = activeCtx;
@@ -75,15 +90,6 @@ api.process = ({
     // update active context to one computed from last iteration
     activeCtx = rval;
 
-    // get context from cache if available
-    if(api.cache) {
-      const cached = api.cache.get(activeCtx, ctx);
-      if(cached) {
-        rval = activeCtx = cached;
-        continue;
-      }
-    }
-
     // reset to initial context
     if(ctx === null) {
       // We can't nullify if there are protected terms and we're
@@ -102,7 +108,7 @@ api.process = ({
           console.warn('WARNING: invalid context nullification');
           const oldActiveCtx = activeCtx;
           // copy all protected term definitions to fresh initial context
-          rval = activeCtx = api.getInitialContext(options);
+          rval = activeCtx = api.getInitialContext(options).clone();
           for(const [term, _protected] of
             Object.entries(oldActiveCtx.protected)) {
             if(_protected) {
@@ -124,10 +130,23 @@ api.process = ({
           'jsonld.SyntaxError',
           {code: 'invalid protected mode', context: localCtx, protectedMode});
       }
-      rval = activeCtx = api.getInitialContext(options);
+      rval = activeCtx = api.getInitialContext(options).clone();
+      // if context is type-scoped, ensure previous context has been set
+      if(isTypeScopedContext) {
+        rval.previousContext = previousContext.clone();
+      }
       continue;
     }
 
+    // get context from cache if available
+    if(api.cache) {
+      const cached = api.cache.get(activeCtx, ctx);
+      if(cached) {
+        rval = activeCtx = cached;
+        continue;
+      }
+    }
+
     // dereference @context key if present
     if(_isObject(ctx) && '@context' in ctx) {
       ctx = ctx['@context'];
@@ -140,6 +159,9 @@ api.process = ({
         'jsonld.SyntaxError', {code: 'invalid local context', context: ctx});
     }
 
+    // TODO: there is likely a `preivousContext` cloning optimization that
+    // could be applied here (no need to copy it under certain conditions)
+
     // clone context before updating it
     rval = rval.clone();
 
@@ -242,12 +264,22 @@ api.process = ({
         isPropertyTermScopedContext, isTypeScopedContext);
     }
 
+    // if context is type-scoped, ensure previous context has been set
+    if(isTypeScopedContext && !rval.previousContext) {
+      rval.previousContext = previousContext.clone();
+    }
+
     // cache result
     if(api.cache) {
       api.cache.set(activeCtx, ctx, rval);
     }
   }
 
+  // if context is type-scoped, ensure previous context has been set
+  if(isTypeScopedContext && !rval.previousContext) {
+    rval.previousContext = previousContext.clone();
+  }
+
   return rval;
 };
 
@@ -301,10 +333,11 @@ api.createTermDefinition = (
       {code: 'invalid term definition', context: localCtx});
   }
 
+  // keep reference to previous mapping for potential `@protected` check
+  const previousMapping = activeCtx.mappings.get(term);
+
   // remove old mapping
-  let previousMapping = null;
   if(activeCtx.mappings.has(term)) {
-    previousMapping = activeCtx.mappings.get(term);
     activeCtx.mappings.delete(term);
   }
 
@@ -339,11 +372,6 @@ api.createTermDefinition = (
   // create new mapping
   const mapping = {};
   activeCtx.mappings.set(term, mapping);
-  if(isTypeScopedContext) {
-    activeCtx.hasTypeScopedTerms = true;
-    mapping.isTypeScopedTerm = true;
-    mapping.previousMapping = previousMapping;
-  }
   mapping.reverse = false;
 
   // make sure term definition only has expected keywords
@@ -961,6 +989,9 @@ api.getInitialContext = options => {
     child.inverse = null;
     child.getInverse = this.getInverse;
     child.protected = util.clone(this.protected);
+    if(this.previousContext) {
+      child.previousContext = this.previousContext.clone();
+    }
     child.revertTypeScopedTerms = this.revertTypeScopedTerms;
     if('@language' in this) {
       child['@language'] = this['@language'];
@@ -976,31 +1007,10 @@ api.getInitialContext = options => {
    * mappings.
    */
   function _revertTypeScopedTerms() {
-    // optimization: no type-scoped terms to remove, reuse active context
-    if(!this.hasTypeScopedTerms) {
+    if(!this.previousContext) {
       return this;
     }
-    // create clone without type scoped terms
-    const child = this.clone();
-    const entries = child.mappings.entries();
-    for(const [term, mapping] of entries) {
-      if(mapping.isTypeScopedTerm) {
-        if(mapping.previousMapping) {
-          child.mappings.set(term, mapping.previousMapping);
-          if(mapping.previousMapping.protected) {
-            child.protected[term] = true;
-          } else {
-            delete child.protected[term];
-          }
-        } else {
-          child.mappings.delete(term);
-          if(child.protected[term]) {
-            delete child.protected[term];
-          }
-        }
-      }
-    }
-    return child;
+    return this.previousContext.clone();
   }
 };