json-ld 3.0.2 → 3.1.0

data/lib/json/ld/expand.rb

@@ -8,6 +8,18 @@ module JSON::LD
   module Expand
     include Utils
 
+    # The following constant is used to reduce object allocations
+    CONTAINER_INDEX_ID_TYPE = Set.new(%w(@index @id @type)).freeze
+    CONTAINER_GRAPH_INDEX = %w(@graph @index).freeze
+    CONTAINER_INDEX = %w(@index).freeze
+    CONTAINER_ID = %w(@id).freeze
+    CONTAINER_LIST = %w(@list).freeze
+    CONTAINER_TYPE = %w(@type).freeze
+    CONTAINER_GRAPH_ID = %w(@graph @id).freeze
+    KEYS_VALUE_LANGUAGE_TYPE_INDEX_DIRECTION = %w(@value @language @type @index @direction).freeze
+    KEYS_SET_LIST_INDEX = %w(@set @list @index).freeze
+    KEYS_INCLUDED_TYPE = %w(@included @type).freeze
+
     ##
     # Expand an Array or Object given an active context and performing local context expansion.
     #
@@ -18,17 +30,24 @@ module JSON::LD
     #   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'
+      expanded_active_property = context.expand_iri(active_property, vocab: true).to_s if active_property
+
+      # Use a term-specific context, if defined, based on the non-type-scoped context.
+      property_scoped_context = context.term_definitions[active_property].context if active_property && context.term_definitions[active_property]
+
       result = case input
       when Array
         # If element is an array,
-        is_list = context.container(active_property) == %w(@list)
+        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)
@@ -42,45 +61,80 @@ module JSON::LD
 
         value
       when Hash
+        if context.previous_context
+          expanded_key_map = input.keys.inject({}) {|memo, key| memo.merge(key => context.expand_iri(key, vocab: true).to_s)}
+          # Revert any previously type-scoped term definitions, unless this is from a map, a value object or a subject reference
+          revert_context = !from_map &&
+            !expanded_key_map.values.include?('@value') &&
+            !(expanded_key_map.values == ['@id'])
+
+          # If there's a previous context, the context was type-scoped
+          context = context.previous_context if revert_context
+        end
+
+        # Apply property-scoped context after reverting term-scoped context
+        context = property_scoped_context ? context.parse(property_scoped_context, override_protected: true) : context
+
         # If element contains the key @context, set active context to the result of the Context Processing algorithm, passing active context and the value of the @context key as local context.
         if input.has_key?('@context')
           context = context.parse(input.delete('@context'))
           #log_debug("expand") {"context: #{context.inspect}"}
         end
 
+        # Set the type-scoped context to the context on input, for use later
+        type_scoped_context = context
+
         output_object = {}
 
         # 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
+        type_key = nil
+        input.keys.sort.
+          select {|k| context.expand_iri(k, vocab: true, quite: true) == '@type'}.
+          each do |tk|
+
+          type_key ||= tk # Side effect saves the first found key mapping to @type
+          Array(input[tk]).sort.each do |term|
+            term_context = type_scoped_context.term_definitions[term].context if type_scoped_context.term_definitions[term]
+            context = term_context ? context.parse(term_context, propagate: false) : context
           end
         end
 
         # Process each key and value in element. Ignores @nesting content
-        expand_object(input, active_property, context, output_object, ordered: ordered, framing: framing)
+        expand_object(input, active_property, context, output_object,
+                      expanded_active_property: expanded_active_property,
+                      type_scoped_context: type_scoped_context,
+                      type_key: type_key,
+                      ordered: ordered,
+                      framing: framing)
 
         #log_debug("output object") {output_object.inspect}
 
         # If result contains the key @value:
         if value?(output_object)
-          unless (output_object.keys - %w(@value @language @type @index)).empty? &&
-                 !(output_object.key?('@language') && output_object.key?('@type'))
-            # The result must not contain any keys other than @value, @language, @type, and @index. It must not contain both the @language key and the @type key. Otherwise, an invalid value object error has been detected and processing is aborted.
+          keys = output_object.keys
+          unless (keys - KEYS_VALUE_LANGUAGE_TYPE_INDEX_DIRECTION).empty?
+            # The result must not contain any keys other than @direction, @value, @language, @type, and @index. It must not contain both the @language key and the @type key. Otherwise, an invalid value object error has been detected and processing is aborted.
             raise JsonLdError::InvalidValueObject,
             "value object has unknown keys: #{output_object.inspect}"
           end
 
+          if keys.include?('@type') && !(keys & %w(@language @direction)).empty?
+            # @type is inconsistent with either @language or @direction
+            raise JsonLdError::InvalidValueObject,
+            "value object must not include @type with either @language or @direction: #{output_object.inspect}"
+          end
+
           output_object.delete('@language') if output_object.key?('@language') && Array(output_object['@language']).empty?
+          type_is_json = output_object['@type'] == '@json'
           output_object.delete('@type') if output_object.key?('@type') && Array(output_object['@type']).empty?
 
-          # If the value of result's @value key is null, then set result to null.
+          # If the value of result's @value key is null, then set result to null and @type is not @json.
           ary = Array(output_object['@value'])
-          return nil if ary.empty?
+          return nil if ary.empty? && !type_is_json
 
-          if !ary.all? {|v| v.is_a?(String) || v.is_a?(Hash) && v.empty?} && output_object.has_key?('@language')
+          if output_object['@type'] == '@json' && context.processingMode('json-ld-1.1')
+            # Any value of @value is okay if @type: @json
+          elsif !ary.all? {|v| v.is_a?(String) || v.is_a?(Hash) && v.empty?} && output_object.has_key?('@language')
             # Otherwise, if the value of result's @value member is not a string and result contains the key @language, an invalid language-tagged value error has been detected (only strings can be language-tagged) and processing is aborted.
             raise JsonLdError::InvalidLanguageTaggedValue,
                   "when @language is used, @value must be a string: #{output_object.inspect}"
@@ -89,7 +143,7 @@ module JSON::LD
                   t.is_a?(Hash) && t.empty?}
             # Otherwise, if the result has a @type member and its value is not an IRI, an invalid typed value error has been detected and processing is aborted.
             raise JsonLdError::InvalidTypedValue,
-                  "value of @type must be an IRI: #{output_object.inspect}"
+                  "value of @type must be an IRI or '@json': #{output_object.inspect}"
           end
         elsif !output_object.fetch('@type', []).is_a?(Array)
           # Otherwise, if result contains the key @type and its associated value is not an array, set it to an array containing only the associated value.
@@ -99,7 +153,7 @@ module JSON::LD
           # The result must contain at most one other key and that key must be @index. Otherwise, an invalid set or list object error has been detected and processing is aborted.
           raise JsonLdError::InvalidSetOrListObject,
                 "@set or @list may only contain @index: #{output_object.keys.inspect}" unless
-                (output_object.keys - %w(@set @list @index)).empty?
+                (output_object.keys - KEYS_SET_LIST_INDEX).empty?
 
           # If result contains the key @set, then set result to the key's associated value.
           return output_object['@set'] if output_object.key?('@set')
@@ -109,9 +163,9 @@ module JSON::LD
         return nil if output_object.length == 1 && output_object.key?('@language')
 
         # If active property is null or @graph, drop free-floating values as follows:
-        if (active_property || '@graph') == '@graph' &&
+        if (expanded_active_property || '@graph') == '@graph' &&
           (output_object.key?('@value') || output_object.key?('@list') ||
-           (output_object.keys - %w(@id)).empty? && !framing)
+           (output_object.keys - CONTAINER_ID).empty? && !framing)
           #log_debug(" =>") { "empty top-level: " + output_object.inspect}
           return nil
         end
@@ -124,7 +178,11 @@ module JSON::LD
         end
       else
         # Otherwise, unless the value is a number, expand the value according to the Value Expansion rules, passing active property.
-        return nil if input.nil? || active_property.nil? || active_property == '@graph'
+        return nil if input.nil? || active_property.nil? || expanded_active_property == '@graph'
+
+        # Apply property-scoped context
+        context = property_scoped_context ? context.parse(property_scoped_context, override_protected: true) : context
+
         context.expand_value(active_property, input, log_depth: @options[:log_depth])
       end
 
@@ -133,12 +191,19 @@ module JSON::LD
     end
 
   private
-    CONTAINER_MAPPING_INDEX_ID_TYPE = Set.new(%w(@index @id @type)).freeze
 
     # Expand each key and value of element adding them to result
-    def expand_object(input, active_property, context, output_object, ordered:, framing:)
+    def expand_object(input, active_property, context, output_object,
+                      expanded_active_property:,
+                      type_scoped_context:,
+                      type_key:,
+                      ordered:,
+                      framing:)
       nests = []
 
+      input_type = Array(input[type_key]).last
+      input_type = context.expand_iri(input_type, vocab: true, quiet: true) if input_type
+
       # Then, proceed and process each property and value in element as follows:
       keys = ordered ? input.keys.sort : input.keys
       keys.each do |key|
@@ -150,6 +215,11 @@ module JSON::LD
         next if expanded_property.is_a?(RDF::URI) && expanded_property.relative?
         expanded_property = expanded_property.to_s if expanded_property.is_a?(RDF::Resource)
 
+        warn "[DEPRECATION] Blank Node properties deprecated in JSON-LD 1.1." if
+          @options[:validate] &&
+          expanded_property.to_s.start_with?("_:") &&
+          context.processingMode('json-ld-1.1')
+
         #log_debug("expand property") {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
 
         if expanded_property.nil?
@@ -160,11 +230,11 @@ module JSON::LD
         if KEYWORDS.include?(expanded_property)
           # If active property equals @reverse, an invalid reverse property map error has been detected and processing is aborted.
           raise JsonLdError::InvalidReversePropertyMap,
-                "@reverse not appropriate at this point" if active_property == '@reverse'
+                "@reverse not appropriate at this point" if expanded_active_property == '@reverse'
 
-          # If result has already an expanded property member, an colliding keywords error has been detected and processing is aborted.
+          # If result has already an expanded property member (other than @type), an colliding keywords error has been detected and processing is aborted.
           raise JsonLdError::CollidingKeywords,
-                "#{expanded_property} already exists in result" if output_object.has_key?(expanded_property)
+                "#{expanded_property} already exists in result" if output_object.has_key?(expanded_property) && !KEYS_INCLUDED_TYPE.include?(expanded_property)
 
           expanded_value = case expanded_property
           when '@id'
@@ -200,62 +270,106 @@ module JSON::LD
             else
               e_id
             end
+          when '@included'
+            # Included blocks are treated as an array of separate object nodes sharing the same referencing active_property. For 1.0, it is skipped as are other unknown keywords
+            next if context.processingMode('json-ld-1.0')
+            included_result = as_array(expand(value, active_property, context, ordered: ordered, framing: framing))
+
+            # Expanded values must be node objects
+            raise JsonLdError::InvalidIncludedValue, "values of @included must expand to node objects" unless included_result.all? {|e| node?(e)}
+            # As other properties may alias to @included, add this to any other previously expanded values
+            Array(output_object['@included']) + included_result
           when '@type'
             # If expanded property is @type and value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, true for vocab, and true for document relative to expand the value or each of its items.
             #log_debug("@type") {"value: #{value.inspect}"}
-            case value
+            e_type = case value
             when Array
               value.map do |v|
                 raise JsonLdError::InvalidTypeValue,
                       "@type value must be a string or array of strings: #{v.inspect}" unless v.is_a?(String)
-                context.expand_iri(v, vocab: true, documentRelative: true, quiet: true).to_s
+                type_scoped_context.expand_iri(v, vocab: true, documentRelative: true, quiet: true).to_s
               end
             when String
-              context.expand_iri(value, vocab: true, documentRelative: true, quiet: true).to_s
+              type_scoped_context.expand_iri(value, vocab: true, documentRelative: true, quiet: true).to_s
             when Hash
-              # For framing
-              raise JsonLdError::InvalidTypeValue,
-                    "@type value must be a an empty object for framing: #{value.inspect}" unless
-                    value.empty? && framing
-              [{}]
+              if !framing
+                raise JsonLdError::InvalidTypeValue,
+                      "@type value must be a string or array of strings: #{value.inspect}"
+              elsif value.keys.length == 1 &&
+                 type_scoped_context.expand_iri(value.keys.first, vocab: true, quiet: true).to_s == '@default'
+                # Expand values of @default, which must be a string, or array of strings expanding to IRIs
+                [{'@default' => Array(value['@default']).map do |v|
+                  raise JsonLdError::InvalidTypeValue,
+                        "@type default value must be a string or array of strings: #{v.inspect}" unless v.is_a?(String)
+                  type_scoped_context.expand_iri(v, vocab: true, documentRelative: true, quiet: true).to_s
+                end}]
+              elsif !value.empty?
+                raise JsonLdError::InvalidTypeValue,
+                      "@type value must be a an empty object for framing: #{value.inspect}"
+              else
+                [{}]
+              end
             else
               raise JsonLdError::InvalidTypeValue,
                     "@type value must be a string or array of strings: #{value.inspect}"
             end
+
+            e_type = Array(output_object['@type']) + Array(e_type)
+            # Use array form if framing
+            framing || e_type.length > 1 ? e_type : e_type.first
           when '@graph'
             # If expanded property is @graph, set expanded value to the result of using this algorithm recursively passing active context, @graph for active property, and value for element.
             value = expand(value, '@graph', context, ordered: ordered, framing: framing)
             as_array(value)
           when '@value'
-            # If expanded property is @value and value is not a scalar or null, an invalid value object value error has been detected and processing is aborted. Otherwise, set expanded value to value. If expanded value is null, set the @value member of result to null and continue with the next key from element. Null values need to be preserved in this case as the meaning of an @type member depends on the existence of an @value member.
+            # If expanded property is @value and input contains @type: json, accept any value.
+            # If expanded property is @value and value is not a scalar or null, an invalid value object value error has been detected and processing is aborted. (In 1.1, @value can have any JSON value of @type is @json or the property coerces to @json).
+            # Otherwise, set expanded value to value. If expanded value is null, set the @value member of result to null and continue with the next key from element. Null values need to be preserved in this case as the meaning of an @type member depends on the existence of an @value member.
             # If framing, always use array form, unless null
-            case value
-            when String, TrueClass, FalseClass, Numeric then (framing ? [value] : value)
-            when nil
-              output_object['@value'] = nil
-              next;
-            when Array
-              raise JsonLdError::InvalidValueObjectValue,
-                    "@value value may not be an array unless framing: #{value.inspect}" unless framing
+            if input_type == '@json' && context.processingMode('json-ld-1.1')
               value
-            when Hash
-              raise JsonLdError::InvalidValueObjectValue,
-                    "@value value must be a an empty object for framing: #{value.inspect}" unless
-                    value.empty? && framing
-              [value]
             else
-              raise JsonLdError::InvalidValueObjectValue,
-                    "Value of #{expanded_property} must be a scalar or null: #{value.inspect}"
+              case value
+              when String, TrueClass, FalseClass, Numeric then (framing ? [value] : value)
+              when nil
+                output_object['@value'] = nil
+                next;
+              when Array
+                raise JsonLdError::InvalidValueObjectValue,
+                      "@value value may not be an array unless framing: #{value.inspect}" unless framing
+                value
+              when Hash
+                raise JsonLdError::InvalidValueObjectValue,
+                      "@value value must be a an empty object for framing: #{value.inspect}" unless
+                      value.empty? && framing
+                [value]
+              else
+                raise JsonLdError::InvalidValueObjectValue,
+                      "Value of #{expanded_property} must be a scalar or null: #{value.inspect}"
+              end
             end
           when '@language'
             # If expanded property is @language and value is not a string, an invalid language-tagged string error has been detected and processing is aborted. Otherwise, set expanded value to lowercased value.
             # If framing, always use array form, unless null
             case value
-            when String then (framing ? [value.downcase] : value.downcase)
+            when String
+              if value !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
+                warn "@language must be valid BCP47: #{value.inspect}"
+              end
+              if @options[:lowercaseLanguage]
+                (framing ? [value.downcase] : value.downcase)
+              else
+                (framing ? [value] : value)
+              end
             when Array
               raise JsonLdError::InvalidLanguageTaggedString,
                     "@language value may not be an array unless framing: #{value.inspect}" unless framing
-              value.map(&:downcase)
+              value.each do |v|
+                if v !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
+                  warn "@language must be valid BCP47: #{v.inspect}"
+                end
+              end
+              @options[:lowercaseLanguage] ? value.map(&:downcase) : value
             when Hash
               raise JsonLdError::InvalidLanguageTaggedString,
                     "@language value must be a an empty object for framing: #{value.inspect}" unless
@@ -265,16 +379,36 @@ module JSON::LD
               raise JsonLdError::InvalidLanguageTaggedString,
                     "Value of #{expanded_property} must be a string: #{value.inspect}"
             end
+          when '@direction'
+            # If expanded property is @direction and value is not either 'ltr' or 'rtl', an invalid base direction error has been detected and processing is aborted. Otherwise, set expanded value to value.
+            # If framing, always use array form, unless null
+            case value
+            when 'ltr', 'rtl' then (framing ? [value] : value)
+            when Array
+              raise JsonLdError::InvalidBaseDirection,
+                    "@direction value may not be an array unless framing: #{value.inspect}" unless framing
+              raise JsonLdError::InvalidBaseDirection,
+                    "@direction must be one of 'ltr', 'rtl', or an array of those if framing #{value.inspect}" unless value.all? {|v| %w(ltr rtl).include?(v) || v.is_a?(Hash) && v.empty?}
+              value
+            when Hash
+              raise JsonLdError::InvalidBaseDirection,
+                    "@direction value must be a an empty object for framing: #{value.inspect}" unless
+                    value.empty? && framing
+              [value]
+            else
+              raise JsonLdError::InvalidBaseDirection,
+                    "Value of #{expanded_property} must be one of 'ltr' or 'rtl': #{value.inspect}"
+            end
           when '@index'
             # If expanded property is @index and value is not a string, an invalid @index value error has been detected and processing is aborted. Otherwise, set expanded value to value.
             raise JsonLdError::InvalidIndexValue,
                   "Value of @index is not a string: #{value.inspect}" unless value.is_a?(String)
             value
           when '@list'
-            # If expanded property is @list:
+            # If expanded property is @graph:
 
             # If active property is null or @graph, continue with the next key from element to remove the free-floating list.
-            next if (active_property || '@graph') == '@graph'
+            next if (expanded_active_property || '@graph') == '@graph'
 
             # Otherwise, initialize expanded value to the result of using this algorithm recursively passing active context, active property, and value for element.
             value = expand(value, active_property, context, ordered: ordered, framing: framing)
@@ -339,15 +473,15 @@ module JSON::LD
 
           # Unless expanded value is null, set the expanded property member of result to expanded value.
           #log_debug("expand #{expanded_property}") { expanded_value.inspect}
-          output_object[expanded_property] = expanded_value unless expanded_value.nil?
+          output_object[expanded_property] = expanded_value unless expanded_value.nil? && expanded_property == '@value' && input_type != '@json'
           next
         end
 
-        # 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) : context
-        container = active_context.container(key)
-        expanded_value = if container.length == 1 && container.first == '@language' && value.is_a?(Hash)
+        container = context.container(key)
+        expanded_value = if context.coerce(key) == '@json'
+          # In JSON-LD 1.1, values can be native JSON
+          {"@value" => value, "@type" => "@json"}
+        elsif container.length == 1 && container.first == '@language' && value.is_a?(Hash)
           # Otherwise, if key's container mapping in active context is @language and value is a JSON object then value is expanded from a language map as follows:
           
           # Set multilingual array to an empty array.
@@ -356,7 +490,12 @@ module JSON::LD
           # For each key-value pair language-language value in value, ordered lexicographically by language
           keys = ordered ? value.keys.sort : value.keys
           keys.each do |k|
-            expanded_k = active_context.expand_iri(k, vocab: true, quiet: true).to_s
+            expanded_k = context.expand_iri(k, vocab: true, quiet: true).to_s
+
+            if k !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/ && expanded_k != '@none'
+              warn "@language must be valid BCP47: #{k.inspect}"
+            end
+
             [value[k]].flatten.each do |item|
               # item must be a string, otherwise an invalid language map value error has been detected and processing is aborted.
               raise JsonLdError::InvalidLanguageMapValue,
@@ -364,47 +503,68 @@ module JSON::LD
 
               # Append a JSON object to expanded value that consists of two key-value pairs: (@value-item) and (@language-lowercased language).
               v = {'@value' => item}
-              v['@language'] = k.downcase unless expanded_k == '@none'
+              v['@language'] = (@options[:lowercaseLanguage] ? k.downcase : k) unless expanded_k == '@none'
+              v['@direction'] = context.direction(key) if context.direction(key)
               ary << v if item
             end
           end
 
           ary
-        elsif container.any? { |key| CONTAINER_MAPPING_INDEX_ID_TYPE.include?(key) } && value.is_a?(Hash)
+        elsif container.any? { |key| CONTAINER_INDEX_ID_TYPE.include?(key) } && value.is_a?(Hash)
           # Otherwise, if key's container mapping in active context contains @index, @id, @type and value is a JSON object then value is expanded from an index map as follows:
           
           # Set ary to an empty array.
           ary = []
+          index_key = context.term_definitions[key].index || '@index'
+
+          # While processing index keys, if container includes @type, clear type-scoped term definitions
+          container_context = if container.include?('@type') && context.previous_context
+            context.previous_context
+          elsif container.include?('@id') && context.term_definitions[key]
+            id_context = context.term_definitions[key].context if context.term_definitions[key]
+            id_context ? context.parse(id_context, propagate: false) : context
+          else
+            context
+          end
 
           # For each key-value in the object:
           keys = ordered ? value.keys.sort : value.keys
           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
+            map_context = container_context.term_definitions[k].context if container.include?('@type') && container_context.term_definitions[k]
+            map_context = container_context.parse(map_context, propagate: false) if map_context
+            map_context ||= container_context
 
-            expanded_k = active_context.expand_iri(k, vocab: true, quiet: true).to_s
+            expanded_k = container_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 %w(@graph @index), %w(@index)
+              when CONTAINER_GRAPH_INDEX, CONTAINER_INDEX
                 # Indexed graph by graph name
                 if !graph?(item) && container.include?('@graph')
                   item = {'@graph' => as_array(item)}
                 end
-                item['@index'] ||= k unless expanded_k == '@none'
-              when %w(@graph @id), %w(@id)
+                if index_key == '@index'
+                  item['@index'] ||= k unless expanded_k == '@none'
+                elsif value?(item)
+                  raise JsonLdError::InvalidValueObject, "Attempt to add illegal key to value object: #{index_key}"
+                else
+                  # Expand key based on term
+                  expanded_k = k == '@none' ? '@none' : container_context.expand_value(index_key, k)
+                  index_property = container_context.expand_iri(index_key, vocab: true, quiet: true).to_s
+                  item[index_property] = [expanded_k].concat(Array(item[index_property])) unless expanded_k == '@none'
+                end
+              when CONTAINER_GRAPH_ID, CONTAINER_ID
                 # Indexed graph by graph name
                 if !graph?(item) && container.include?('@graph')
                   item = {'@graph' => as_array(item)}
                 end
                 # Expand k document relative
-                expanded_k = active_context.expand_iri(k, documentRelative: true, quiet: true).to_s unless expanded_k == '@none'
+                expanded_k = container_context.expand_iri(k, documentRelative: true, quiet: true).to_s unless expanded_k == '@none'
                 item['@id'] ||= expanded_k unless expanded_k == '@none'
-              when %w(@type)
+              when CONTAINER_TYPE
                 item['@type'] = [expanded_k].concat(Array(item['@type'])) unless expanded_k == '@none'
               end
 
@@ -415,7 +575,7 @@ module JSON::LD
           ary
         else
           # Otherwise, initialize expanded value to the result of using this algorithm recursively, passing active context, key for active property, and value for element.
-          expand(value, key, active_context, ordered: ordered, framing: framing)
+          expand(value, key, context, ordered: ordered, framing: framing)
         end
 
         # If expanded value is null, ignore key by continuing to the next key from element.
@@ -436,7 +596,7 @@ module JSON::LD
         if container.first == '@graph' && container.length == 1
           #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
           expanded_value = as_array(expanded_value).map do |v|
-            graph?(v) ? v : {'@graph' => as_array(v)}
+            {'@graph' => as_array(v)}
           end
         end
 
@@ -474,7 +634,12 @@ module JSON::LD
         nested_values.each do |nv|
           raise JsonLdError::InvalidNestValue, nv.inspect unless
             nv.is_a?(Hash) && nv.keys.none? {|k| context.expand_iri(k, vocab: true) == '@value'}
-          expand_object(nv, active_property, context, output_object, ordered: ordered, framing: framing)
+          expand_object(nv, active_property, context, output_object,
+                        expanded_active_property: expanded_active_property,
+                        type_scoped_context: type_scoped_context,
+                        type_key: type_key,
+                        ordered: ordered,
+                        framing: framing)
         end
       end
     end