* Use propagate and overrideProtected options instead of isTypeScopedContext/isPropertyScopedContext.

Author: gkellogg

lib/compact.js

@@ -102,11 +102,11 @@ api.compact = async ({
   // use any scoped context on activeProperty
   const ctx = _getContextValue(activeCtx, activeProperty, '@context');
   if(!_isUndefined(ctx)) {
-    // Note: spec's `from term` var is named `isPropertyTermScopedContext`
     activeCtx = await _processContext({
       activeCtx,
       localCtx: ctx,
-      isPropertyTermScopedContext: true,
+      propagate: true,
+      overrideProtected: true,
       options
     });
   }
@@ -159,8 +159,26 @@ api.compact = async ({
 
     const rval = {};
 
-    // revert type scoped context
-    activeCtx = activeCtx.revertTypeScopedContext();
+    // original context before applying property-scoped and local contexts
+    const inputCtx = activeCtx;
+
+    // revert to previous context, if there is one,
+    // and element is  not a value object or a node reference
+    if(!_isValue(element) && !_isSubjectReference(element)) {
+      activeCtx = activeCtx.revertToPreviousContext();
+    }
+
+    // apply property-scoped context after reverting term-scoped context
+    const propertyScopedCtx = _getContextValue(inputCtx, activeProperty, '@context');
+    if(!_isUndefined(propertyScopedCtx)) {
+      activeCtx = await _processContext({
+        activeCtx,
+        localCtx: propertyScopedCtx,
+        propagate: true,
+        overrideProtected: true,
+        options
+      });
+    }
 
     if(options.link && '@id' in element) {
       // store linked element
@@ -185,13 +203,13 @@ api.compact = async ({
         {activeCtx: typeContext, iri: type, relativeTo: {vocab: true}});
 
       // Use any type-scoped context defined on this value
-      const ctx = _getContextValue(typeContext, compactedType, '@context');
+      const ctx = _getContextValue(inputCtx, compactedType, '@context');
       if(!_isUndefined(ctx)) {
         activeCtx = await _processContext({
           activeCtx,
           localCtx: ctx,
           options,
-          isTypeScopedContext: true
+          propagate: false
         });
       }
     }

lib/context.js

@@ -42,17 +42,16 @@ api.cache = new ActiveContextCache();
  * @param activeCtx the current active context.
  * @param localCtx the local context to process.
  * @param options the context processing options.
- * @param isPropertyTermScopedContext `true` if `localCtx` is a scoped context
- *   from a property term.
- * @param isTypeScopedContext `true` if `localCtx` is a scoped context
- *   from a type.
+ * @param propagate `true` if `false`, retains any previously defined term,
+ *   which can be rolled back when the descending into a new node object changes.
+ * @param overrideProtected `false` allows protected terms to be modified.
  *
  * @return a Promise that resolves to the new active context.
  */
 api.process = async ({
   activeCtx, localCtx, options,
-  isPropertyTermScopedContext = false,
-  isTypeScopedContext = false
+  propagate = true,
+  overrideProtected = false,
 }) => {
   // normalize local context to an array of @context objects
   if(_isObject(localCtx) && '@context' in localCtx &&
@@ -66,27 +65,22 @@ api.process = async ({
     return activeCtx;
   }
 
-  // track the previous context
-  const previousContext = activeCtx.previousContext || activeCtx;
-
-  // if context is property scoped and there's a previous context, amend it,
-  // not the current one
-  if(isPropertyTermScopedContext && activeCtx.previousContext) {
-    // TODO: consider optimizing to a shallow copy
-    activeCtx = activeCtx.clone();
-    activeCtx.isPropertyTermScoped = true;
-    activeCtx.previousContext = await api.process({
-      activeCtx: activeCtx.previousContext,
-      localCtx: ctxs,
-      options,
-      isPropertyTermScopedContext
-    });
-    return activeCtx;
+  // override propagate if localCtx has `@propagate`
+  if(_isObject(ctxs[0]) && '@propagate' in ctxs[0]) {
+    // Retrieve early, error checking done later
+    propagate = ctxs[0]['@propagate'];
   }
 
   // process each context in order, update active context
   // on each iteration to ensure proper caching
   let rval = activeCtx;
+
+  // track the previous context
+  // If not propagating, make sure rval has a previous context
+  if(!propagate && !rval.previousContext) {
+    rval.previousContext = activeCtx.clone();
+  }
+
   for(let i = 0; i < ctxs.length; ++i) {
     let ctx = ctxs[i];
 
@@ -97,7 +91,7 @@ api.process = async ({
     if(ctx === null) {
       // We can't nullify if there are protected terms and we're
       // not processing a property term scoped context
-      if(!isPropertyTermScopedContext &&
+      if(!overrideProtected &&
         Object.keys(activeCtx.protected).length !== 0) {
         const protectedMode = (options && options.protectedMode) || 'error';
         if(protectedMode === 'error') {
@@ -134,10 +128,6 @@ api.process = async ({
           {code: 'invalid protected mode', context: localCtx, protectedMode});
       }
       rval = activeCtx = api.getInitialContext(options).clone();
-      // if context is type-scoped, ensure previous context has been set
-      if(isTypeScopedContext) {
-        rval.previousContext = previousContext.clone();
-      }
       continue;
     }
 
@@ -256,6 +246,25 @@ api.process = async ({
       defined.set('@language', true);
     }
 
+    // handle @propagate
+    // note: we've already extracted it, here we just do error checking
+    if('@propagate' in ctx) {
+      const value = ctx['@propagate'];
+      if(activeCtx.processingMode === 'json-ld-1.0') {
+        throw new JsonLdError(
+          'Invalid JSON-LD syntax; @propagate not compatible with ' +
+          activeCtx.processingMode,
+          'jsonld.SyntaxError',
+          {code: 'invalid context member', context: ctx});
+      }
+      if(typeof value !== 'boolean') {
+        throw new JsonLdError(
+          'Invalid JSON-LD syntax; @propagate must be boolean valued',
+          'jsonld.SyntaxError',
+          {code: 'invalid @propagate value', context: localCtx});
+      }
+    }
+
     // handle @protected; determine whether this sub-context is declaring
     // all its terms to be "protected" (exceptions can be made on a
     // per-definition basis)
@@ -294,12 +303,11 @@ api.process = async ({
  * @param {string} [options.protectedMode="error"] - "error" to throw error
  *   on `@protected` constraint violation, "warn" to allow violations and
  *   signal a warning.
- * @param isPropertyTermScopedContext `true` if `localCtx` is a scoped context
- *   from a property term.
+ * @param overrideProtected `false` allows protected terms to be modified.
  */
 api.createTermDefinition = (
   activeCtx, localCtx, term, defined, options,
-  isPropertyTermScopedContext = false) => {
+  overrideProtected = false) => {
   if(defined.has(term)) {
     // term already defined
     if(defined.get(term)) {
@@ -699,9 +707,8 @@ api.createTermDefinition = (
       'jsonld.SyntaxError', {code: 'invalid keyword alias', context: localCtx});
   }
 
-  // FIXME if(1.1) ... ?
-  if(previousMapping && previousMapping.protected &&
-    !isPropertyTermScopedContext) {
+  // Check for overriding protected terms
+  if(previousMapping && previousMapping.protected && !overrideProtected) {
     // force new term to continue to be protected and see if the mappings would
     // be equal
     activeCtx.protected[term] = true;
@@ -776,11 +783,6 @@ function _expandIri(activeCtx, value, relativeTo, localCtx, defined, options) {
     api.createTermDefinition(activeCtx, localCtx, value, defined, options);
   }
 
-  // if context is from a property term scoped context composed with a
-  // type-scoped context, then use previous context instead
-  if(activeCtx.isPropertyTermScoped && activeCtx.previousContext) {
-    activeCtx = activeCtx.previousContext;
-  }
 
   relativeTo = relativeTo || {};
   if(relativeTo.vocab) {
@@ -862,7 +864,7 @@ api.getInitialContext = options => {
     inverse: null,
     getInverse: _createInverseContext,
     clone: _cloneActiveContext,
-    revertTypeScopedContext: _revertTypeScopedContext,
+    revertToPreviousContext: _revertToPreviousContext,
     protected: {}
   };
   // TODO: consider using LRU cache instead
@@ -1039,10 +1041,9 @@ api.getInitialContext = options => {
     child.getInverse = this.getInverse;
     child.protected = util.clone(this.protected);
     if(this.previousContext) {
-      child.isPropertyTermScoped = this.previousContext.isPropertyTermScoped;
       child.previousContext = this.previousContext.clone();
     }
-    child.revertTypeScopedContext = this.revertTypeScopedContext;
+    child.revertToPreviousContext = this.revertToPreviousContext;
     if('@language' in this) {
       child['@language'] = this['@language'];
     }
@@ -1056,7 +1057,7 @@ api.getInitialContext = options => {
    * Reverts any type-scoped context in this active context to the previous
    * context.
    */
-  function _revertTypeScopedContext() {
+  function _revertToPreviousContext() {
     if(!this.previousContext) {
       return this;
     }

lib/expand.js

@@ -157,6 +157,9 @@ api.expand = async ({
   const expandedActiveProperty = _expandIri(
     activeCtx, activeProperty, {vocab: true}, options);
 
+  // Get any property-scoped context for activeProperty
+  const propertyScopedCtx = _getContextValue(activeCtx, activeProperty, '@context');
+
   // second, determine if any type-scoped context should be reverted; it
   // should only be reverted when the following are all true:
   // 1. `element` is not a value or subject reference
@@ -186,7 +189,18 @@ api.expand = async ({
 
   if(mustRevert) {
     // revert type scoped context
-    activeCtx = activeCtx.revertTypeScopedContext();
+    activeCtx = activeCtx.revertToPreviousContext();
+  }
+
+  // apply property-scoped context after reverting term-scoped context
+  if(!_isUndefined(propertyScopedCtx)) {
+    activeCtx = await _processContext({
+      activeCtx,
+      localCtx: propertyScopedCtx,
+      propagate: true,
+      overrideProtected: true,
+      options
+    });
   }
 
   // if element has a context, process it
@@ -370,6 +384,7 @@ api.expand = async ({
  * @param expandedParent the expanded result into which to add values.
  * @param options the expansion options.
  * @param insideList true if the element is a list, false if not.
+ * @param typeScopedContext the context before reverting.
  * @param expansionMap(info) a function that can be used to custom map
  *          unmappable values (or to throw an error when they are detected);
  *          if this function returns `undefined` then the default behavior
@@ -383,6 +398,7 @@ async function _expandObject({
   expandedParent,
   options = {},
   insideList,
+  typeScopedContext,
   expansionMap
 }) {
   const keys = Object.keys(element).sort();
@@ -593,11 +609,11 @@ async function _expandObject({
     let termCtx = activeCtx;
     const ctx = _getContextValue(activeCtx, key, '@context');
     if(!_isUndefined(ctx)) {
-      // Note: spec's `from term` var is named `isPropertyTermScopedContext`
       termCtx = await _processContext({
         activeCtx,
         localCtx: ctx,
-        isPropertyTermScopedContext: true,
+        propagate: true,
+        overrideProtected: true,
         options
       });
     }
@@ -640,7 +656,7 @@ async function _expandObject({
       // handle type container (skip if value is not an object)
       expandedValue = await _expandIndexMap({
         // since container is `@type`, revert type scoped context when expanding
-        activeCtx: termCtx.revertTypeScopedContext(),
+        activeCtx: termCtx.revertToPreviousContext(),
         options,
         activeProperty: key,
         value,
@@ -907,7 +923,7 @@ async function _expandIndexMap(
         activeCtx = await _processContext({
           activeCtx,
           localCtx: ctx,
-          isTypeScopedContext: true,
+          propagate: false,
           options
         });
       }