json-ld 3.1.3 → 3.1.8

data/lib/json/ld/expand.rb

@@ -11,9 +11,9 @@ module JSON::LD
     # The following constant is used to reduce object allocations
     CONTAINER_INDEX_ID_TYPE = Set['@index', '@id', '@type'].freeze
     KEY_ID = %w(@id).freeze
-    KEYS_VALUE_LANGUAGE_TYPE_INDEX_DIRECTION = %w(@value @language @type @index @direction).freeze
+    KEYS_VALUE_LANGUAGE_TYPE_INDEX_DIRECTION = %w(@value @language @type @index @direction @annotation).freeze
     KEYS_SET_LIST_INDEX = %w(@set @list @index).freeze
-    KEYS_INCLUDED_TYPE = %w(@included @type).freeze
+    KEYS_INCLUDED_TYPE_REVERSE = %w(@included @type @reverse).freeze
 
     ##
     # Expand an Array or Object given an active context and performing local context expansion.
@@ -21,20 +21,21 @@ module JSON::LD
     # @param [Array, Hash] input
     # @param [String] active_property
     # @param [Context] context
-    # @param [Boolean] ordered (true)
-    #   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, from_map: false)
-      log_debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
+    def expand(input, active_property, context,
+               framing: false, from_map: false, log_depth: nil)
+      log_debug("expand", depth: log_depth.to_i) {"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, as_string: true) if active_property
+      expanded_active_property = context.expand_iri(active_property, vocab: true, as_string: true, base: @options[:base]) 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]
+      log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{property_scoped_context.inspect}"} unless property_scoped_context.nil?
 
       result = case input
       when Array
@@ -42,10 +43,19 @@ module JSON::LD
         is_list = context.container(active_property).include?('@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, from_map: from_map)
+          v = expand(v, active_property, context,
+            framing: framing,
+            from_map: from_map,
+            log_depth: log_depth.to_i + 1)
 
           # 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)
+          if is_list && v.is_a?(Array)
+            # Make sure that no member of v contains an annotation object
+            raise JsonLdError::InvalidAnnotation,
+              "A list element must not contain @annotation." if
+              v.any? {|n| n.is_a?(Hash) && n.key?('@annotation')}
+            v = {"@list" => v}
+          end
 
           case v
           when nil then nil
@@ -57,23 +67,29 @@ 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, as_string: true))}
+          expanded_key_map = input.keys.inject({}) do |memo, key|
+            memo.merge(key => context.expand_iri(key, vocab: true, as_string: true, base: @options[:base]))
+          end
           # 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
+          log_debug("expand", depth: log_depth.to_i) {"previous_context: #{context.previous_context.inspect}"} if revert_context
           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
+        unless property_scoped_context.nil?
+          context = context.parse(property_scoped_context, base: @options[:base], override_protected: true)
+        end
+        log_debug("expand", depth: log_depth.to_i) {"after property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
 
         # 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}"}
+        if input.key?('@context')
+          context = context.parse(input.delete('@context'), base: @options[:base])
+          log_debug("expand", depth: log_depth.to_i) {"context: #{context.inspect}"}
         end
 
         # Set the type-scoped context to the context on input, for use later
@@ -84,25 +100,28 @@ module JSON::LD
         # See if keys mapping to @type have terms with a local context
         type_key = nil
         input.keys.sort.
-          select {|k| context.expand_iri(k, vocab: true, quite: true) == '@type'}.
+          select {|k| context.expand_iri(k, vocab: true, base: @options[:base]) == '@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
+            unless term_context.nil?
+              log_debug("expand", depth: log_depth.to_i) {"term_context: #{term_context.inspect}"}
+              context = context.parse(term_context, base: @options[:base], propagate: false)
+            end
           end
         end
 
         # Process each key and value in element. Ignores @nesting content
         expand_object(input, active_property, context, output_object,
                       expanded_active_property: expanded_active_property,
-                      type_scoped_context: type_scoped_context,
+                      framing: framing,
                       type_key: type_key,
-                      ordered: ordered,
-                      framing: framing)
+                      type_scoped_context: type_scoped_context,
+                      log_depth: log_depth.to_i + 1)
 
-        log_debug("output object") {output_object.inspect}
+        log_debug("output object", depth: log_depth.to_i) {output_object.inspect}
 
         # If result contains the key @value:
         if value?(output_object)
@@ -110,13 +129,13 @@ module JSON::LD
           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}"
+              "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}"
+              "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?
@@ -129,13 +148,20 @@ module JSON::LD
 
           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')
+          elsif !ary.all? {|v| v.is_a?(String) || v.is_a?(Hash) && v.empty?} && output_object.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}"
-          elsif !Array(output_object['@type']).all? {|t|
-                  t.is_a?(String) && RDF::URI(t).valid? && !t.start_with?('_:') ||
-                  t.is_a?(Hash) && t.empty?}
+          elsif output_object['@type'] &&
+            (!Array(output_object['@type']).all? {|t|
+                t.is_a?(String) && RDF::URI(t).valid? && !t.start_with?('_:') ||
+                t.is_a?(Hash) && t.empty?} ||
+             !framing && !output_object['@type'].is_a?(String))
+            # 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 or '@json': #{output_object.inspect}"
+          elsif !framing && !output_object.fetch('@type', '').is_a?(String) &&
+                  RDF::URI(t).valid? && !t.start_with?('_:')
             # 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 or '@json': #{output_object.inspect}"
@@ -152,6 +178,18 @@ module JSON::LD
 
           # If result contains the key @set, then set result to the key's associated value.
           return output_object['@set'] if output_object.key?('@set')
+        elsif output_object['@annotation']
+          # Otherwise, if result contains the key @annotation,
+          # the array value must all be node objects without an @id property, otherwise, an invalid annotation error has been detected and processing is aborted.
+          raise JsonLdError::InvalidAnnotation,
+            "@annotation must reference node objects without @id." unless
+            output_object['@annotation'].all? {|o| node?(o) && !o.key?('@id')}
+
+          # Additionally, the property must not be used if there is no active property, or the expanded active property is @graph.
+          raise JsonLdError::InvalidAnnotation,
+            "@annotation must not be used on a top-level object." if
+            %w(@graph @included).include?(expanded_active_property || '@graph')
+          
         end
 
         # If result contains only the key @language, set result to null.
@@ -161,12 +199,12 @@ module JSON::LD
         if (expanded_active_property || '@graph') == '@graph' &&
            (output_object.key?('@value') || output_object.key?('@list') ||
            (output_object.keys - KEY_ID).empty? && !framing)
-          log_debug(" =>") { "empty top-level: " + output_object.inspect}
+          log_debug(" =>", depth: log_depth.to_i) { "empty top-level: " + output_object.inspect}
           return nil
         end
 
         # Re-order result keys if ordering
-        if ordered
+        if @options[:ordered]
           output_object.keys.sort.each_with_object({}) {|kk, memo| memo[kk] = output_object[kk]}
         else
           output_object
@@ -176,12 +214,17 @@ module JSON::LD
         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
+        unless property_scoped_context.nil?
+          context = context.parse(property_scoped_context,
+                                  base: @options[:base],
+                                  override_protected: true)
+        end
+        log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
 
-        context.expand_value(active_property, input, log_depth: @options[:log_depth])
+        context.expand_value(active_property, input, base: @options[:base])
       end
 
-      log_debug {" => #{result.inspect}"}
+      log_debug(depth: log_depth.to_i) {" => #{result.inspect}"}
       result
     end
 
@@ -190,21 +233,21 @@ module JSON::LD
     # Expand each key and value of element adding them to result
     def expand_object(input, active_property, context, output_object,
                       expanded_active_property:,
-                      type_scoped_context:,
+                      framing:,
                       type_key:,
-                      ordered:,
-                      framing:)
+                      type_scoped_context:,
+                      log_depth: nil)
       nests = []
 
       input_type = Array(input[type_key]).last
-      input_type = context.expand_iri(input_type, vocab: true, as_string: true) if input_type
+      input_type = context.expand_iri(input_type, vocab: true, as_string: true, base: @options[:base]) if input_type
 
       # Then, proceed and process each property and value in element as follows:
-      keys = ordered ? input.keys.sort : input.keys
+      keys = @options[:ordered] ? input.keys.sort : input.keys
       keys.each do |key|
         # For each key and value in element, ordered lexicographically by key:
         value = input[key]
-        expanded_property = context.expand_iri(key, vocab: true)
+        expanded_property = context.expand_iri(key, vocab: true, base: @options[:base])
 
         # If expanded property is null or it neither contains a colon (:) nor it is a keyword, drop key by continuing to the next key.
         next if expanded_property.is_a?(RDF::URI) && expanded_property.relative?
@@ -215,10 +258,10 @@ module JSON::LD
           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}"}
+        #log_debug("expand property", depth: log_depth.to_i) {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
 
         if expanded_property.nil?
-          #log_debug(" => ") {"skip nil property"}
+          #log_debug(" => ", depth: log_depth.to_i) {"skip nil property"}
           next
         end
 
@@ -229,31 +272,51 @@ module JSON::LD
 
           # 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) && !KEYS_INCLUDED_TYPE.include?(expanded_property)
+                "#{expanded_property} already exists in result" if output_object.key?(expanded_property) && !KEYS_INCLUDED_TYPE_REVERSE.include?(expanded_property)
 
           expanded_value = case expanded_property
           when '@id'
+            # If expanded active property is `@annotation`, an invalid annotation error has been found and processing is aborted.
+            raise JsonLdError::InvalidAnnotation,
+              "an annotation must not contain a property expanding to @id" if
+              expanded_active_property == '@annotation' && @options[:rdfstar]
+
             # If expanded property is @id and value is not a string, an invalid @id value error has been detected and processing is aborted
             e_id = case value
             when String
-              context.expand_iri(value, documentRelative: true, as_string: true)
+              context.expand_iri(value, as_string: true, base: @options[:base], documentRelative: true)
             when Array
               # Framing allows an array of IRIs, and always puts values in an array
               raise JsonLdError::InvalidIdValue,
                     "value of @id must be a string unless framing: #{value.inspect}" unless framing
-              context.expand_iri(value, documentRelative: true, as_string: true)
+              context.expand_iri(value, as_string: true, base: @options[:base], documentRelative: true)
               value.map do |v|
                 raise JsonLdError::InvalidTypeValue,
                       "@id value must be a string or array of strings for framing: #{v.inspect}" unless v.is_a?(String)
-                context.expand_iri(v, documentRelative: true, as_string: true)
+                context.expand_iri(v, as_string: true, base: @options[:base], documentRelative: true)
               end
             when Hash
-              raise JsonLdError::InvalidIdValue,
-                    "value of @id must be a string unless framing: #{value.inspect}" unless framing
-              raise JsonLdError::InvalidTypeValue,
-                    "value of @id must be a an empty object for framing: #{value.inspect}" unless
-                    value.empty?
-              [{}]
+              if framing
+                raise JsonLdError::InvalidTypeValue,
+                      "value of @id must be a an empty object for framing: #{value.inspect}" unless
+                      value.empty?
+                [{}]
+              elsif @options[:rdfstar]
+                # Result must have just a single statement
+                rei_node = expand(value, nil, context, log_depth: log_depth.to_i + 1)
+
+                # Node must not contain @reverse
+                raise JsonLdError::InvalidEmbeddedNode,
+                      "Embedded node with @reverse" if rei_node && rei_node.key?('@reverse')
+                statements = to_enum(:item_to_rdf, rei_node)
+                raise JsonLdError::InvalidEmbeddedNode,
+                      "Embedded node with #{statements.size} statements" unless
+                      statements.count == 1
+                rei_node
+              else
+                raise JsonLdError::InvalidIdValue,
+                      "value of @id must be a string unless framing: #{value.inspect}" unless framing
+              end
             else
               raise JsonLdError::InvalidIdValue,
                     "value of @id must be a string or hash if framing: #{value.inspect}"
@@ -268,7 +331,9 @@ module JSON::LD
           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))
+            included_result = as_array(expand(value, active_property, context,
+              framing: framing,
+              log_depth: log_depth.to_i + 1))
 
             # Expanded values must be node objects
             raise JsonLdError::InvalidIncludedValue, "values of @included must expand to node objects" unless included_result.all? {|e| node?(e)}
@@ -276,27 +341,39 @@ module JSON::LD
             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}"}
+            #log_debug("@type", depth: log_depth.to_i) {"value: #{value.inspect}"}
             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)
-                type_scoped_context.expand_iri(v, vocab: true, documentRelative: true, as_string: true)
+                type_scoped_context.expand_iri(v,
+                  as_string: true,
+                  base: @options[:base],
+                  documentRelative: true,
+                  vocab: true)
               end
             when String
-              type_scoped_context.expand_iri(value, vocab: true, documentRelative: true, as_string: true)
+              type_scoped_context.expand_iri(value,
+                as_string: true,
+                base: @options[:base],
+                documentRelative: true,
+                vocab: true)
             when Hash
               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) == '@default'
+                 type_scoped_context.expand_iri(value.keys.first, vocab: true, base: @options[:base]) == '@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, as_string: true)
+                  type_scoped_context.expand_iri(v,
+                    as_string: true,
+                    base: @options[:base],
+                    documentRelative: true,
+                    vocab: true)
                 end}]
               elsif !value.empty?
                 raise JsonLdError::InvalidTypeValue,
@@ -314,7 +391,9 @@ module JSON::LD
             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)
+            value = expand(value, '@graph', context,
+              framing: framing,
+              log_depth: log_depth.to_i + 1)
             as_array(value)
           when '@value'
             # If expanded property is @value and input contains @type: json, accept any value.
@@ -406,15 +485,24 @@ module JSON::LD
             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)
+            value = expand(value, active_property, context,
+              framing: framing,
+              log_depth: log_depth.to_i + 1)
 
             # Spec FIXME: need to be sure that result is an array
             value = as_array(value)
 
+            # Make sure that no member of value contains an annotation object
+            raise JsonLdError::InvalidAnnotation,
+              "A list element must not contain @annotation." if
+              value.any? {|n| n.is_a?(Hash) && n.key?('@annotation')}
+
             value
           when '@set'
             # If expanded property is @set, set expanded value to the result of using this algorithm recursively, passing active context, active property, and value for element.
-            expand(value, active_property, context, ordered: ordered, framing: framing)
+            expand(value, active_property, context,
+              framing: framing,
+              log_depth: log_depth.to_i + 1)
           when '@reverse'
             # If expanded property is @reverse and value is not a JSON object, an invalid @reverse value error has been detected and processing is aborted.
             raise JsonLdError::InvalidReverseValue,
@@ -422,11 +510,13 @@ module JSON::LD
 
             # Otherwise
             # Initialize expanded value to the result of using this algorithm recursively, passing active context, @reverse as active property, and value as element.
-            value = expand(value, '@reverse', context, ordered: ordered, framing: framing)
+            value = expand(value, '@reverse', context,
+              framing: framing,
+              log_depth: log_depth.to_i + 1)
 
             # If expanded value contains an @reverse member, i.e., properties that are reversed twice, execute for each of its property and item the following steps:
-            if value.has_key?('@reverse')
-              #log_debug("@reverse") {"double reverse: #{value.inspect}"}
+            if value.key?('@reverse')
+              #log_debug("@reverse", depth: log_depth.to_i) {"double reverse: #{value.inspect}"}
               value['@reverse'].each do |property, item|
                 # If result does not have a property member, create one and set its value to an empty array.
                 # Append item to the value of the property member of result.
@@ -455,19 +545,28 @@ module JSON::LD
           when '@default', '@embed', '@explicit', '@omitDefault', '@preserve', '@requireAll'
             next unless framing
             # Framing keywords
-            [expand(value, expanded_property, context, ordered: ordered, framing: framing)].flatten
+            [expand(value, expanded_property, context,
+              framing: framing,
+              log_depth: log_depth.to_i + 1)
+            ].flatten
           when '@nest'
             # Add key to nests
             nests << key
             # Continue with the next key from element
             next
+          when '@annotation'
+            # Skip unless rdfstar option is set
+            next unless @options[:rdfstar]
+            as_array(expand(value, '@annotation', context,
+              framing: framing,
+              log_depth: log_depth.to_i + 1))
           else
             # Skip unknown keyword
             next
           end
 
           # Unless expanded value is null, set the expanded property member of result to expanded value.
-          #log_debug("expand #{expanded_property}") { expanded_value.inspect}
+          #log_debug("expand #{expanded_property}", depth: log_depth.to_i) { expanded_value.inspect}
           output_object[expanded_property] = expanded_value unless expanded_value.nil? && expanded_property == '@value' && input_type != '@json'
           next
         end
@@ -483,9 +582,9 @@ module JSON::LD
           ary = []
 
           # For each key-value pair language-language value in value, ordered lexicographically by language
-          keys = ordered ? value.keys.sort : value.keys
+          keys = @options[:ordered] ? value.keys.sort : value.keys
           keys.each do |k|
-            expanded_k = context.expand_iri(k, vocab: true, as_string: true)
+            expanded_k = context.expand_iri(k, vocab: true, as_string: true, base: @options[:base])
 
             if k !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/ && expanded_k != '@none'
               warn "@language must be valid BCP47: #{k.inspect}"
@@ -517,23 +616,35 @@ module JSON::LD
             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
+            if id_context.nil?
+              context
+            else
+              log_debug("expand", depth: log_depth.to_i) {"id_context: #{id_context.inspect}"}
+              context.parse(id_context, base: @options[:base], propagate: false)
+            end
           else
             context
           end
 
           # For each key-value in the object:
-          keys = ordered ? value.keys.sort : value.keys
+          keys = @options[: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 = 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
+            unless map_context.nil?
+              log_debug("expand", depth: log_depth.to_i) {"map_context: #{map_context.inspect}"}
+              map_context = container_context.parse(map_context, base: @options[:base],
+                                                    propagate: false)
+            end
             map_context ||= container_context
 
-            expanded_k = container_context.expand_iri(k, vocab: true, as_string: true)
+            expanded_k = container_context.expand_iri(k, vocab: true, as_string: true, base: @options[:base])
 
             # 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, from_map: true)
+            index_value = expand([value[k]].flatten, key, map_context,
+              framing: framing,
+              from_map: true,
+              log_depth: log_depth.to_i + 1)
             index_value.each do |item|
               case
               when container.include?('@index')
@@ -547,8 +658,8 @@ module JSON::LD
                   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, as_string: true)
+                  expanded_k = k == '@none' ? '@none' : container_context.expand_value(index_key, k, base: @options[:base])
+                  index_property = container_context.expand_iri(index_key, vocab: true, as_string: true, base: @options[:base])
                   item[index_property] = [expanded_k].concat(Array(item[index_property])) unless expanded_k == '@none'
                 end
               when container.include?('@id')
@@ -557,7 +668,7 @@ module JSON::LD
                   item = {'@graph' => as_array(item)}
                 end
                 # Expand k document relative
-                expanded_k = container_context.expand_iri(k, documentRelative: true, as_string: true) unless expanded_k == '@none'
+                expanded_k = container_context.expand_iri(k, as_string: true, base: @options[:base], documentRelative: true) unless expanded_k == '@none'
                 item['@id'] ||= expanded_k unless expanded_k == '@none'
               when container.include?('@type')
                 item['@type'] = [expanded_k].concat(Array(item['@type'])) unless expanded_k == '@none'
@@ -570,26 +681,28 @@ 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, context, ordered: ordered, framing: framing)
+          expand(value, key, context,
+            framing: framing,
+            log_depth: log_depth.to_i + 1)
         end
 
         # If expanded value is null, ignore key by continuing to the next key from element.
         if expanded_value.nil?
-          #log_debug(" => skip nil value")
+          #log_debug(" => skip nil value", depth: log_depth.to_i)
           next
         end
-        #log_debug {" => #{expanded_value.inspect}"}
+        #log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
 
         # If the container mapping associated to key in active context is @list and expanded value is not already a list object, convert expanded value to a list object by first setting it to an array containing only expanded value if it is not already an array, and then by setting it to a JSON object containing the key-value pair @list-expanded value.
         if container.first == '@list' && container.length == 1 && !list?(expanded_value)
-          #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
+          #log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
           expanded_value = {'@list' => as_array(expanded_value)}
         end
-        #log_debug {" => #{expanded_value.inspect}"}
+        #log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
 
         # convert expanded value to @graph if container specifies it
         if container.first == '@graph' && container.length == 1
-          #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
+          #log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
           expanded_value = as_array(expanded_value).map do |v|
             {'@graph' => as_array(v)}
           end
@@ -626,17 +739,23 @@ module JSON::LD
       # For each key in nests, recusively expand content
       nests.each do |key|
         nest_context = context.term_definitions[key].context if context.term_definitions[key]
-        nest_context = nest_context ? context.parse(nest_context, override_protected: true) : context
+        nest_context = if nest_context.nil?
+          context
+        else
+          log_debug("expand", depth: log_depth.to_i) {"nest_context: #{nest_context.inspect}"}
+          context.parse(nest_context, base: @options[:base],
+                        override_protected: true)
+        end
         nested_values = as_array(input[key])
         nested_values.each do |nv|
           raise JsonLdError::InvalidNestValue, nv.inspect unless
-            nv.is_a?(Hash) && nv.keys.none? {|k| nest_context.expand_iri(k, vocab: true) == '@value'}
+            nv.is_a?(Hash) && nv.keys.none? {|k| nest_context.expand_iri(k, vocab: true, base: @options[:base]) == '@value'}
           expand_object(nv, active_property, nest_context, output_object,
+                        framing: framing,
                         expanded_active_property: expanded_active_property,
-                        type_scoped_context: type_scoped_context,
                         type_key: type_key,
-                        ordered: ordered,
-                        framing: framing)
+                        type_scoped_context: type_scoped_context,
+                        log_depth: log_depth.to_i + 1)
         end
       end
     end