type-scoped contexts disappear when used in sub-objects.

This is for w3c/json-ld-api#89.

Author: gkellogg

lib/json/ld/compact.rb

@@ -30,7 +30,7 @@ def compact(element, property: nil, ordered: false)
       # If the term definition for active property itself contains a context, use that for compacting values.
       input_context = self.context
       td = self.context.term_definitions[property] if property
-      self.context = (td && td.context && self.context.parse(td.context, from_term: property)) || input_context
+      self.context = (td && td.context && self.context.parse(td.context, from_property: property)) || input_context
 
       case element
       when Array
@@ -67,18 +67,20 @@ def compact(element, property: nil, ordered: false)
           return compact(element['@list'], property: property, ordered: ordered)
         end
 
-
         inside_reverse = property == '@reverse'
         result, nest_result = {}, nil
 
+        # Revert any previously type-scoped term definitions
+        self.context = context.revert_type_scoped_terms
+
         # Apply any context defined on an alias of @type
         # If key is @type and any compacted value is a term having a local context, overlay that context.
         Array(element['@type']).
           map {|expanded_type| context.compact_iri(expanded_type, vocab: true)}.
           sort.
           each do |term|
           term_context = self.context.term_definitions[term].context if context.term_definitions[term]
-          self.context = context.parse(term_context) if term_context
+          self.context = context.parse(term_context, from_type: true) if term_context
         end
 
         element.keys.opt_sort(ordered: ordered).each do |expanded_property|

lib/json/ld/context.rb

@@ -78,6 +78,14 @@ class TermDefinition
       # @return [Boolean]
       attr_writer :protected
 
+      # Previous definition defined for this term. This is used for rolling back term definitions based on scoped types.
+      # @return [TermDefinition]
+      attr_reader :previous_definition
+
+      # Definition is from a type-scoped context.
+      # @return [TermDefinition]
+      attr_reader :type_scoped
+
       # This is a simple term definition, not an expanded term definition
       # @return [Boolean] simple
       def simple?; simple; end
@@ -90,6 +98,8 @@ def prefix?; @prefix; end
       # @param [String] term
       # @param [String] id
       # @param [String] type_mapping Type mapping
+      # @param [Boolean] type_scoped
+      # @param [TermDefinition] previous_definition
       # @param [Array<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>] container_mapping
       # @param [String] language_mapping
       #   Language mapping of term, `false` is used if there is explicitly no language mapping for this term
@@ -104,6 +114,8 @@ def initialize(term,
                     id: nil,
                     index: nil,
                     type_mapping: nil,
+                    previous_definition: nil,
+                    type_scoped: false,
                     container_mapping: nil,
                     language_mapping: nil,
                     reverse_property: false,
@@ -116,6 +128,8 @@ def initialize(term,
         @id                     = id.to_s           unless id.nil?
         @index                  = index.to_s        unless index.nil?
         @type_mapping           = type_mapping.to_s unless type_mapping.nil?
+        @previous_definition    = previous_definition
+        @type_scoped            = type_scoped
         self.container_mapping  = container_mapping
         @language_mapping       = language_mapping  unless language_mapping.nil?
         @reverse_property       = reverse_property
@@ -241,6 +255,10 @@ def inspect
     # @return [Hash{String => TermDefinition}]
     attr_reader :term_definitions
 
+    # Context has definitions defined from type scopes
+    # @return [Boolean]
+    attr_accessor :has_typed_scopes
+
     # @return [Hash{RDF::URI => String}] Reverse mappings from IRI to term only for terms, not CURIEs XXX
     attr_accessor :iri_to_term
 
@@ -279,8 +297,8 @@ def inspect
     # @raise [JsonLdError]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
     # @return [Context]
-    def self.parse(local_context, from_term: nil, **options)
-      self.new(options).parse(local_context, from_term: from_term)
+    def self.parse(local_context, from_property: false, from_type: false, **options)
+      self.new(options).parse(local_context, from_property: from_property, from_type: from_type)
     end
 
     ##
@@ -409,15 +427,16 @@ def vocab=(value)
     #
     # @param [String, #read, Array, Hash, Context] local_context
     # @param [Array<String>] remote_contexts
-    # @param [String] from_term
-    #   The active term, when expanding. Sealed terms may not be cleared unless from a
-    #   context associated with a term used as a property.
+    # @param [Boolean] from_property
+    #   Context is created from a scoped context for a property. Sealed terms may not be cleared unless from a context associated with a term used as a property.
+    # @param [Boolean] from_type
+    #   Context is created from a scoped context for a type. Retains any previously defined term, which can be rolled back when the type context changes.
     # @param [RDF::Resource] context_id from context IRI, for sealing terms
     # @raise [JsonLdError]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
     # @return [Context]
     # @see https://www.w3.org/TR/json-ld11-api/index.html#context-processing-algorithm
-    def parse(local_context, remote_contexts: [], from_term: nil)
+    def parse(local_context, remote_contexts: [], from_property: false, from_type: false)
       result = self.dup
       result.provided_context = local_context if self.empty?
 
@@ -426,8 +445,8 @@ def parse(local_context, remote_contexts: [], from_term: nil)
       local_context.each do |context|
         case context
         when nil
-          # 3.1 If the `from_term` is  not null, and the active context contains protected terms, an error is raised.
-          if from_term || result.term_definitions.values.none?(&:protected?)
+          # 3.1 If the `from_property` is  not null, and the active context contains protected terms, an error is raised.
+          if from_property || result.term_definitions.values.none?(&:protected?)
             result = Context.new(options)
           else
             raise JSON::LD::JsonLdError::InvalidContextNullification,
@@ -502,7 +521,7 @@ def parse(local_context, remote_contexts: [], from_term: nil)
             end
 
             # 3.2.6) Set context to the result of recursively calling this algorithm, passing context no base for active context, context for local context, and remote contexts.
-            context = context_no_base.parse(context, remote_contexts: remote_contexts.dup, from_term: from_term)
+            context = context_no_base.parse(context, remote_contexts: remote_contexts.dup, from_property: from_property, from_type: from_type)
             PRELOADED[context_canon.to_s] = context
             context.provided_context = result.provided_context
           end
@@ -532,7 +551,8 @@ def parse(local_context, remote_contexts: [], from_term: nil)
           context.each_key do |key|
             # ... where key is not @base, @vocab, @language, or @version
             result.create_term_definition(context, key, defined,
-                                          from_term: from_term,
+                                          from_property: from_property,
+                                          from_type: from_type,
                                           protected: context['@protected']) unless NON_TERMDEF_KEYS.include?(key)
           end
         else
@@ -590,14 +610,15 @@ def merge!(context)
     # @param [Hash] local_context
     # @param [String] term
     # @param [Hash] defined
-    # @param [String] from_term
-    #   The active term, when expanding. Sealed terms may not be cleared unless from a
-    #   context associated with a term used as a property.
+    # @param [Boolean] from_property
+    #   Context is created from a scoped context for a property. Sealed terms may not be cleared unless from a context associated with a term used as a property.
+    # @param [Boolean] from_type
+    #   Context is created from a scoped context for a type. Retains any previously defined term, which can be rolled back when the type context changes.
     # @param [Boolean] protected if true, causes all terms to be marked protected
     # @raise [JsonLdError]
     #   Represents a cyclical term dependency
     # @see https://www.w3.org/TR/json-ld11-api/index.html#create-term-definition
-    def create_term_definition(local_context, term, defined, from_term: nil, protected: false)
+    def create_term_definition(local_context, term, defined, from_property: false, from_type: false, protected: false)
       # Expand a string value, unless it matches a keyword
       #log_debug("create_term_definition") {"term = #{term.inspect}"}
 
@@ -627,22 +648,24 @@ def create_term_definition(local_context, term, defined, from_term: nil, protect
       value = {'@id' => value} if simple_term
 
       # Remove any existing term definition for term in active context.
-      if term_definitions[term] && term_definitions[term].protected? && from_term.nil?
+      previous_definition = term_definitions[term]
+      if previous_definition && previous_definition.protected? && !from_property
         raise JSON::LD::JsonLdError::ProtectedTermRedefinition, "Attempt to redefine protected term #{term}"
       else
-        term_definitions.delete(term) unless term_definitions[term]
+        term_definitions.delete(term) if previous_definition
       end
 
       case value
       when nil, ID_NULL_OBJECT
         # If value equals null or value is a JSON object containing the key-value pair (@id-null), then set the term definition in active context to null, set the value associated with defined's key term to true, and return.
         #log_debug("") {"=> nil"}
-        term_definitions[term] = TermDefinition.new(term)
+        term_definitions[term] = TermDefinition.new(term, previous_definition: previous_definition, type_scoped: from_type)
+        self.has_typed_scopes ||= from_type
         defined[term] = true
         return
       when Hash
         #log_debug("") {"Hash[#{term.inspect}] = #{value.inspect}"}
-        definition = TermDefinition.new(term)
+        definition = TermDefinition.new(term, previous_definition: previous_definition, type_scoped: from_type)
         definition.simple = simple_term
 
         if options[:validate]
@@ -774,7 +797,7 @@ def create_term_definition(local_context, term, defined, from_term: nil, protect
 
         if value.has_key?('@context')
           begin
-            self.parse(value['@context'], from_term: term)
+            self.parse(value['@context'], from_property: true)
             # Record null context in array form
             definition.context = value['@context'] ? value['@context'] : [nil]
           rescue JsonLdError => e
@@ -809,6 +832,7 @@ def create_term_definition(local_context, term, defined, from_term: nil, protect
         end
 
         term_definitions[term] = definition
+        self.has_typed_scopes ||= from_type
         defined[term] = true
       else
         raise JsonLdError::InvalidTermDefinition, "Term definition for #{term.inspect} is an #{value.class} on term #{term.inspect}"
@@ -934,6 +958,27 @@ def from_vocabulary(graph)
       self
     end
 
+    ##
+    # Revert any type-scoped terms in this context to their previous mappings.
+    #
+    # Creates a clone of the context with terms associated with type-scoped contexts reverted to their prior state
+    def revert_type_scoped_terms
+      return self unless has_typed_scopes
+
+      ctx = self.dup
+      ctx.term_definitions.each do |term, definition|
+        if definition.type_scoped
+          if definition.previous_definition
+            ctx.term_definitions[term] = definition.previous_definition
+          else
+            ctx.term_definitions.delete(term)
+          end
+        end
+      end
+
+      ctx
+    end
+
     # Set term mapping
     #
     # @param [#to_s] term

lib/json/ld/expand.rb

@@ -29,8 +29,10 @@ module Expand
     #   Ensure output objects have keys ordered properly
     # @param [Boolean] framing (false)
     #   Special rules for expanding a frame
+    # @param [Boolean] from_map
+    #   Expanding from a map, which could be an `@type` map, so don't clear out context term definitions
     # @return [Array<Hash{String => Object}>]
-    def expand(input, active_property, context, ordered: false, framing: false)
+    def expand(input, active_property, context, ordered: false, framing: false, from_map: false)
       #log_debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       framing = false if active_property == '@default'
       result = case input
@@ -39,7 +41,7 @@ def expand(input, active_property, context, ordered: false, framing: false)
         is_list = context.container(active_property) == CONTAINER_LIST
         value = input.each_with_object([]) do |v, memo|
           # Initialize expanded item to the result of using this algorithm recursively, passing active context, active property, and item as element.
-          v = expand(v, active_property, context, ordered: ordered, framing: framing)
+          v = expand(v, active_property, context, ordered: ordered, framing: framing, from_map: from_map)
 
           # If the active property is @list or its container mapping is set to @list and v is an array, change it to a list object
           v = {"@list" => v} if is_list && v.is_a?(Array)
@@ -61,12 +63,15 @@ def expand(input, active_property, context, ordered: false, framing: false)
 
         output_object = {}
 
+        # Revert any previously type-scoped term definitions
+        context = context.revert_type_scoped_terms unless from_map
+
         # See if keys mapping to @type have terms with a local context
         input.each_pair do |key, val|
           next unless context.expand_iri(key, vocab: true) == '@type'
           Array(val).sort.each do |term|
             term_context = context.term_definitions[term].context if context.term_definitions[term]
-            context = term_context ? context.parse(term_context) : context
+            context = term_context ? context.parse(term_context, from_type: true) : context
           end
         end
 
@@ -375,7 +380,7 @@ def expand_object(input, active_property, context, output_object, ordered:, fram
 
         # Use a term-specific context, if defined
         term_context = context.term_definitions[key].context if context.term_definitions[key]
-        active_context = term_context ? context.parse(term_context, from_term: key) : context
+        active_context = term_context ? context.parse(term_context, from_property: true) : context
 
         container = active_context.container(key)
         expanded_value = if active_context.coerce(key) == '@json'
@@ -416,13 +421,13 @@ def expand_object(input, active_property, context, output_object, ordered:, fram
           keys.each do |k|
             # If container mapping in the active context includes @type, and k is a term in the active context having a local context, use that context when expanding values
             map_context = active_context.term_definitions[k].context if container.include?('@type') && active_context.term_definitions[k]
-            map_context = active_context.parse(map_context) if map_context
+            map_context = active_context.parse(map_context, from_type: true) if map_context
             map_context ||= active_context
 
             expanded_k = active_context.expand_iri(k, vocab: true, quiet: true).to_s
 
             # Initialize index value to the result of using this algorithm recursively, passing active context, key as active property, and index value as element.
-            index_value = expand([value[k]].flatten, key, map_context, ordered: ordered, framing: framing)
+            index_value = expand([value[k]].flatten, key, map_context, ordered: ordered, framing: framing, from_map: true)
             index_value.each do |item|
               case container
               when CONTAINER_GRAPH_INDEX, CONTAINER_INDEX

spec/compact_spec.rb

@@ -2312,7 +2312,7 @@
             "a": {"type": "Foo", "bar": "baz"}
           }),
         },
-        "deep @context affects nested nodes" => {
+        "deep @context does not affect nested nodes" => {
           input: %([
             {
               "@type": ["http://example/Foo"],
@@ -2331,7 +2331,7 @@
               "Foo": {"@context": {"baz": {"@type": "@vocab"}}}
             },
             "@type": "Foo",
-            "bar": {"baz": "buzz"}
+            "bar": {"baz": {"@id": "http://example/buzz"}}
           }),
         },
         "scoped context layers on intemediate contexts" => {

spec/expand_spec.rb

@@ -2605,7 +2605,7 @@
             }
           ])
         },
-        "deep @context affects nested nodes": {
+        "deep @context does not affect nested nodes": {
           input: %({
             "@context": {
               "@vocab": "http://example/",
@@ -2618,7 +2618,7 @@
             {
               "@type": ["http://example/Foo"],
               "http://example/bar": [{
-                "http://example/baz": [{"@id": "http://example/buzz"}]
+                "http://example/baz": [{"@value": "buzz"}]
               }]
             }
           ])