json-ld 2.1.2 → 2.1.3

data/lib/json/ld/context.rb

@@ -36,9 +36,12 @@ module JSON::LD
       # @return [String] Type mapping
       attr_accessor :type_mapping
 
-      # @return ['@set', '@list'] Container mapping
+      # @return ['@index', '@language', '@index', '@set', '@type', '@id'] Container mapping
       attr_accessor :container_mapping
 
+      # @return [String] Term used for nest properties
+      attr_accessor :nest
+
       # Language mapping of term, `false` is used if there is explicitly no language mapping for this term.
       # @return [String] Language mapping
       attr_accessor :language_mapping
@@ -47,9 +50,13 @@ module JSON::LD
       attr_accessor :reverse_property
 
       # This is a simple term definition, not an expanded term definition
-      # @return [Boolean] simple
+      # @return [Boolean]
       attr_accessor :simple
 
+      # Term-specific context
+      # @return [Hash{String => Object}]
+      attr_accessor :context
+
       # This is a simple term definition, not an expanded term definition
       # @return [Boolean] simple
       def simple?; simple; end
@@ -58,10 +65,11 @@ module JSON::LD
       # @param [String] term
       # @param [String] id
       # @param [String] type_mapping Type mapping
-      # @param ['@set', '@list'] container_mapping
+      # @param ['@index', '@language', '@index', '@set', '@type', '@id'] container_mapping
       # @param [String] language_mapping
       #   Language mapping of term, `false` is used if there is explicitly no language mapping for this term
       # @param [Boolean] reverse_property
+      # @param [String] nest term used for nest properties
       # @param [Boolean] simple
       #   This is a simple term definition, not an expanded term definition
       def initialize(term,
@@ -70,14 +78,18 @@ module JSON::LD
                     container_mapping: nil,
                     language_mapping: nil,
                     reverse_property: false,
-                    simple: false)
+                    nest: nil,
+                    simple: false,
+                    context: nil)
         @term               = term
         @id                 = id.to_s           if id
         @type_mapping       = type_mapping.to_s if type_mapping
         @container_mapping  = container_mapping if container_mapping
         @language_mapping   = language_mapping  if language_mapping
         @reverse_property   = reverse_property  if reverse_property
+        @nest               = nest              if nest
         @simple             = simple            if simple
+        @context            = context           if context
       end
 
       ##
@@ -98,7 +110,9 @@ module JSON::LD
         if language_mapping.nil? &&
            container_mapping.nil? &&
            type_mapping.nil? &&
-           reverse_property.nil?
+           reverse_property.nil? &&
+           self.context.nil? &&
+           nest.nil?
 
            cid.to_s unless cid == term && context.vocab
         else
@@ -114,16 +128,19 @@ module JSON::LD
           defn['@container'] = container_mapping if container_mapping
           # Language set as false to be output as null
           defn['@language'] = (language_mapping ? language_mapping : nil) unless language_mapping.nil?
+          defn['@context'] = self.context unless self.context.nil?
+          defn['@nest'] = selfnest unless self.nest.nil?
           defn
         end
       end
 
       ##
       # Turn this into a source for a new instantiation
+      # FIXME: context serialization
       # @return [String]
       def to_rb
         defn = [%(TermDefinition.new\(#{term.inspect})]
-        %w(id type_mapping container_mapping language_mapping reverse_property simple).each do |acc|
+        %w(id type_mapping container_mapping language_mapping reverse_property nest simple context).each do |acc|
           v = instance_variable_get("@#{acc}".to_sym)
           v = v.to_s if v.is_a?(RDF::Term)
           defn << "#{acc}: #{v.inspect}" if v
@@ -139,6 +156,8 @@ module JSON::LD
         v << "container=#{container_mapping}" if container_mapping
         v << "lang=#{language_mapping.inspect}" unless language_mapping.nil?
         v << "type=#{type_mapping}" unless type_mapping.nil?
+        v << "nest=#{nest.inspect}" unless nest.nil?
+        v << "has-context" unless context.nil?
         v.join(" ") + "]"
       end
     end
@@ -186,6 +205,9 @@ module JSON::LD
     # @return [BlankNodeNamer]
     attr_accessor :namer
 
+    # @return [String]
+    attr_accessor :processingMode
+
     ##
     # Create a new context by parsing a context.
     #
@@ -223,6 +245,7 @@ module JSON::LD
         @doc_base.canonicalize! if options[:canonicalize]
       end
       options[:documentLoader] ||= JSON::LD::API.method(:documentLoader)
+      @processingMode ||= options[:processingMode]
       @term_definitions = {}
       @iri_to_term = {
         RDF.to_uri.to_s => "rdf",
@@ -283,6 +306,22 @@ module JSON::LD
       end
     end
 
+    # If contex has a @version member, it's value MUST be 1.1, otherwise an "invalid @version value" has been detected, and processing is aborted.
+    #   If processingMode has been set, and "json-ld-1.1" is not a prefix of processingMode , a "processing mode conflict" has been detecting, and processing is aborted.
+    # @param [Number] vaule must be a decimal number
+    def version=(value)
+      case value
+      when 1.1
+        if processingMode && !processingMode.start_with?("json-ld-1.1")
+          raise JsonLdError::ProcessingModeConflict, "#{value} not compatible with #{processingMode}"
+        end
+        @processingMode ||= "json-ld-1.1"
+      else
+        raise JsonLdError::InvalidVersionValue, value
+      end
+    end
+
+    # If context has a @vocab member: if its value is not a valid absolute IRI or null trigger an INVALID_VOCAB_MAPPING error; otherwise set the active context's vocabulary mapping to its value and remove the @vocab member from context.
     # @param [String] value must be an absolute IRI
     def vocab=(value)
       @vocab = case value
@@ -380,18 +419,18 @@ module JSON::LD
                 end
                 raise JsonLdError::InvalidRemoteContext, "#{context}" unless jo.is_a?(Hash) && jo.has_key?('@context')
                 context = jo['@context']
-                if @options[:processingMode] == "json-ld-1.0"
+                if processingMode && processingMode <= "json-ld-1.1"
                   context_no_base.provided_context = context.dup
                 end
               end
             rescue JsonLdError::LoadingDocumentFailed => e
               #log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
-              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}", e.backtrace
+              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}: #{e.message}", e.backtrace
             rescue JsonLdError
               raise
-            rescue Exception => e
+            rescue StandardError => e
               #log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
-              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}", e.backtrace
+              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}: #{e.message}", e.backtrace
             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.
@@ -402,11 +441,12 @@ module JSON::LD
           result = context
           #log_debug("parse") {"=> provided_context: #{context.inspect}"}
         when Hash
-          # If context has a @vocab member: if its value is not a valid absolute IRI or null trigger an INVALID_VOCAB_MAPPING error; otherwise set the active context's vocabulary mapping to its value and remove the @vocab member from context.
           context = context.dup # keep from modifying a hash passed as a param
+
           {
             '@base'     => :base=,
             '@language' => :default_language=,
+            '@version'  => :version=,
             '@vocab'    => :vocab=,
           }.each do |key, setter|
             v = context.fetch(key, false)
@@ -417,6 +457,9 @@ module JSON::LD
             end
           end
 
+          # If not set explicitly, set processingMode to "json-ld-1.0"
+          result.processingMode ||= "json-ld-1.0"
+
           defined = {}
         # For each key-value pair in context invoke the Create Term Definition subalgorithm, passing result for active context, context for local context, key, and defined
           context.each_key do |key|
@@ -454,6 +497,7 @@ module JSON::LD
 
       # Merge in Term Definitions
       term_definitions.merge!(context.term_definitions)
+      @inverse_context = nil  # Re-build after term definitions set
       self
     end
 
@@ -484,7 +528,7 @@ module JSON::LD
       end
 
       # Since keywords cannot be overridden, term must not be a keyword. Otherwise, an invalid value has been detected, which is an error.
-      if KEYWORDS.include?(term) && !%w(@vocab @language).include?(term)
+      if KEYWORDS.include?(term) && !%w(@vocab @language @version).include?(term)
         raise JsonLdError::KeywordRedefinition, "term must not be a keyword: #{term.inspect}" if
           @options[:validate]
       elsif !term_valid?(term) && @options[:validate]
@@ -511,6 +555,16 @@ module JSON::LD
         definition = TermDefinition.new(term)
         definition.simple = simple_term
 
+        expected_keys = case @options[:processingMode]
+        when "json-ld-1.0" then %w(@id @reverse @type @container @language)
+        else  %w(@id @reverse @type @container @language @context @nest)
+        end
+
+        extra_keys = value.keys - expected_keys
+        if !extra_keys.empty? && @options[:validate]
+          raise JsonLdError::InvalidTermDefinition, "Term definition for #{term.inspect} has unexpected keys: #{extra_keys.join(', ')}"
+        end
+
         if value.has_key?('@type')
           type = value['@type']
           # SPEC FIXME: @type may be nil
@@ -535,7 +589,7 @@ module JSON::LD
 
         if value.has_key?('@reverse')
           raise JsonLdError::InvalidReverseProperty, "unexpected key in #{value.inspect} on term #{term.inspect}" if
-            value.keys.any? {|k| %w(@id).include?(k)}
+            value.keys.any? {|k| %w(@id @nest).include?(k)}
           raise JsonLdError::InvalidIRIMapping, "expected value of @reverse to be a string: #{value['@reverse'].inspect} on term #{term.inspect}" unless
             value['@reverse'].is_a?(String)
 
@@ -548,12 +602,13 @@ module JSON::LD
           raise JsonLdError::InvalidIRIMapping, "non-absolute @reverse IRI: #{definition.id} on term #{term.inspect}" unless
             definition.id.is_a?(RDF::URI) && definition.id.absolute?
 
-          # If value contains an @container member, set the container mapping of definition to its value; if its value is neither @set, nor @index, nor null, an invalid reverse property error has been detected (reverse properties only support set- and index-containers) and processing is aborted.
-          if (container = value.fetch('@container', false))
+          # If value contains an @container member, set the container mapping of definition to its value; if its value is neither @set, @index, @type, @id, an absolute IRI nor null, an invalid reverse property error has been detected (reverse properties only support set- and index-containers) and processing is aborted.
+          if value.has_key?('@container')
+            container = value['@container']
             raise JsonLdError::InvalidReverseProperty,
                   "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" unless
-                   ['@set', '@index', nil].include?(container)
-            definition.container_mapping = container
+                   ['@set', '@index'].include?(container)
+            definition.container_mapping = check_container(container, local_context, defined, term)
           end
           definition.reverse_property = true
         elsif value.has_key?('@id') && value['@id'] != term
@@ -589,10 +644,20 @@ module JSON::LD
         @iri_to_term[definition.id] = term if simple_term && definition.id
 
         if value.has_key?('@container')
-          container = value['@container']
-          raise JsonLdError::InvalidContainerMapping, "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" unless %w(@list @set @language @index).include?(container)
-          #log_debug("") {"container_mapping: #{container.inspect}"}
-          definition.container_mapping = container
+          #log_debug("") {"container_mapping: #{value['@container'].inspect}"}
+          definition.container_mapping = check_container(value['@container'], local_context, defined, term)
+        end
+
+        if value.has_key?('@context')
+          # Not supported in JSON-LD 1.0
+          raise JsonLdError::InvalidTermDefinition, '@context not valid in term definition for JSON-LD 1.0' if processingMode < 'json-ld-1.1'
+
+          begin
+            self.parse(value['@context'])
+            definition.context = value['@context']
+          rescue JsonLdError => e
+            raise JsonLdError::InvalidScopedContext, "Term definition for #{term.inspect} contains illegal value for @context: #{e.message}"
+          end
         end
 
         if value.has_key?('@language')
@@ -603,11 +668,28 @@ module JSON::LD
           definition.language_mapping = language || false
         end
 
+        if value.has_key?('@nest')
+          # Not supported in JSON-LD 1.0
+          raise JsonLdError::InvalidTermDefinition, '@nest not valid in term definition for JSON-LD 1.0' if processingMode < 'json-ld-1.1'
+
+          # Not supported in JSON-LD 1.0
+          raise JsonLdError::InvalidTermDefinition, '@nest not valid in term definition for JSON-LD 1.0' if processingMode < 'json-ld-1.1'
+
+          nest = value['@nest']
+          raise JsonLdError::InvalidNestValue, "nest must be a string, was #{nest.inspect}} on term #{term.inspect}" unless nest.is_a?(String)
+          raise JsonLdError::InvalidNestValue, "nest must not be a keyword other than @nest, was #{nest.inspect}} on term #{term.inspect}" if nest.start_with?('@') && nest != '@nest'
+          #log_debug("") {"nest: #{nest.inspect}"}
+          definition.nest = nest
+        end
+
         term_definitions[term] = definition
         defined[term] = true
       else
         raise JsonLdError::InvalidTermDefinition, "Term definition for #{term.inspect} is an #{value.class} on term #{term.inspect}"
       end
+    ensure
+      # Re-build after term definitions set
+      @inverse_context = nil
     end
 
     ##
@@ -766,6 +848,37 @@ module JSON::LD
       term && term.container_mapping
     end
 
+    ##
+    # Retrieve content of a term
+    #
+    # @param [Term, #to_s] term in unexpanded form
+    # @return [Hash]
+    def content(term)
+      term = find_definition(term)
+      term && term.content
+    end
+
+    ##
+    # Retrieve nest of a term.
+    # value of nest must be @nest or a term that resolves to @nest
+    #
+    # @param [Term, #to_s] term in unexpanded form
+    # @return [String] Nesting term
+    # @raise JsonLdError::InvalidNestValue if nesting term exists and is not a term resolving to `@nest` in the current context.
+    def nest(term)
+      term = find_definition(term)
+      if term
+        case term.nest
+        when '@nest', nil
+          term.nest
+        else
+          nest_term = find_definition(term.nest)
+          raise JsonLdError::InvalidNestValue, "nest must a term resolving to @nest" unless nest_term && nest_term.simple? && nest_term.id == '@nest'
+          term.nest
+        end
+      end
+    end
+
     ##
     # Retrieve the language associated with a term, or the default language otherwise
     # @param [Term, #to_s] term in unexpanded form
@@ -909,7 +1022,12 @@ module JSON::LD
         default_language = self.default_language || @none
         containers = []
         tl, tl_value = "@language", "@null"
-        containers << '@index' if index?(value)
+
+        # If the value is a JSON Object, then for the keywords @index, @id, and @type, if the value contains that keyword, append it to containers.
+        %w(@index @id @type).each do |kw|
+          containers << kw if value.has_key?(kw)
+        end if value.is_a?(Hash)
+
         if reverse
           tl, tl_value = "@type", "@reverse"
           containers << '@set'
@@ -1220,6 +1338,7 @@ module JSON::LD
       v = %w([Context)
       v << "base=#{base}" if base
       v << "vocab=#{vocab}" if vocab
+      v << "processingMode=#{processingMode}" if processingMode
       v << "default_language=#{default_language}" if default_language
       v << "term_definitions[#{term_definitions.length}]=#{term_definitions}"
       v.join(" ") + "]"
@@ -1438,5 +1557,22 @@ module JSON::LD
         memo
       end
     end
+
+    # Ensure @container mapping is appropriate
+    # The result is the original container definition. For IRI containers, this is necessary to be able to determine the @type mapping for string values
+    def check_container(container, local_context, defined, term)
+      case container
+      when '@set', '@list', '@language', '@index', nil
+        # Okay
+      when '@type', '@id', nil
+        raise JsonLdError::InvalidContainerMapping,
+              "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" if
+              processingMode < 'json-ld-1.1'
+      else
+        raise JsonLdError::InvalidContainerMapping,
+              "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}"
+      end
+      container
+    end
   end
 end

data/lib/json/ld/expand.rb

@@ -42,290 +42,21 @@ module JSON::LD
         end
 
         output_object = {}
-        # Then, proceed and process each property and value in element as follows:
         keys = ordered ? input.keys.kw_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, log_depth: @options[:log_depth])
 
-          # 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?
-          expanded_property = expanded_property.to_s if expanded_property.is_a?(RDF::Resource)
-
-          #log_debug("expand property") {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
-
-          if expanded_property.nil?
-            #log_debug(" => ") {"skip nil property"}
-            next
-          end
-
-          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'
-
-            # If result has already an expanded property member, 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_value = case expanded_property
-            when '@id'
-              # 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, log_depth: @options[:log_depth]).to_s
-              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, array of string or hash if framing: #{value.inspect}" unless framing
-                context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
-                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, quiet: true, log_depth: @options[:log_depth]).to_s
-                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? && framing
-                [{}]
-              else
-                raise JsonLdError::InvalidIdValue,
-                      "value of @id must be a string or hash if framing: #{value.inspect}"
-              end
-
-              # Use array form if framing
-              if framing && !e_id.is_a?(Array)
-                [e_id]
-              else
-                e_id
-              end
-            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
-              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, log_depth: @options[:log_depth]).to_s
-                end
-              when String
-                context.expand_iri(value, vocab: true, documentRelative: true, quiet: true, log_depth: @options[:log_depth]).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
-                [{}]
-              else
-                raise JsonLdError::InvalidTypeValue,
-                      "@type value must be a string or array of strings: #{value.inspect}"
-              end
-            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)
-              value.is_a?(Array) ? value : [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 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
-                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
-            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 Array
-                raise JsonLdError::InvalidLanguageTaggedString,
-                      "@language value may not be an array unless framing: #{value.inspect}" unless framing
-                value.map(&:downcase)
-              when Hash
-                raise JsonLdError::InvalidLanguageTaggedString,
-                      "@language value must be a an empty object for framing: #{value.inspect}" unless
-                      value.empty? && framing
-                [value]
-              else
-                raise JsonLdError::InvalidLanguageTaggedString,
-                      "Value of #{expanded_property} must be a string: #{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 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'
-
-              # 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)
-
-              # Spec FIXME: need to be sure that result is an array
-              value = [value] unless value.is_a?(Array)
-
-              # If expanded value is a list object, a list of lists error has been detected and processing is aborted.
-              # Spec FIXME: Also look at each object if result is an array
-              raise JsonLdError::ListOfLists,
-                    "A list may not contain another list" if value.any? {|v| list?(v)}
-
-              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)
-            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,
-                    "@reverse value must be an object: #{value.inspect}" unless value.is_a?(Hash)
-
-              # 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)
-
-              # 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}"}
-                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.
-                  (output_object[property] ||= []).concat([item].flatten.compact)
-                end
-              end
-
-              # If expanded value contains members other than @reverse:
-              unless value.keys.reject {|k| k == '@reverse'}.empty?
-                # If result does not have an @reverse member, create one and set its value to an empty JSON object.
-                reverse_map = output_object['@reverse'] ||= {}
-                value.each do |property, items|
-                  next if property == '@reverse'
-                  items.each do |item|
-                    if value?(item) || list?(item)
-                      raise JsonLdError::InvalidReversePropertyValue,
-                            item.inspect
-                    end
-                    merge_value(reverse_map, property, item)
-                  end
-                end
-              end
-
-              # Continue with the next key from element
-              next
-            when '@default', '@embed', '@explicit', '@omitDefault', '@preserve', '@requireAll'
-              next unless framing
-              # Framing keywords
-              [expand(value, expanded_property, context, ordered: ordered)].flatten
-            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}
-            output_object[expanded_property] = expanded_value unless expanded_value.nil?
-            next
-          end
-
-          expanded_value = if context.container(key) == '@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.
-            ary = []
-
-            # 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|
-              [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,
-                      "Expected #{item.inspect} to be a string" unless item.is_a?(String)
-
-                # Append a JSON object to expanded value that consists of two key-value pairs: (@value-item) and (@language-lowercased language).
-                ary << {
-                  '@value' => item,
-                  '@language' => k.downcase
-                }
-              end
-            end
-
-            ary
-          elsif context.container(key) == '@index' && value.is_a?(Hash)
-            # Otherwise, if key's container mapping in active context is @index and value is a JSON object then value is expanded from an index map as follows:
-            
-            # Set ary to an empty array.
-            ary = []
-
-            # For each key-value in the object:
-            keys = ordered ? value.keys.sort : value.keys
-            keys.each do |k|
-              # 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, context, ordered: ordered)
-              index_value.each do |item|
-                item['@index'] ||= k
-                ary << item
-              end
-            end
-            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)
-          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")
-            next
-          end
-          #log_debug {" => #{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 context.container(key) == '@list' && !list?(expanded_value)
-            #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
-            expanded_value = {'@list' => [expanded_value].flatten}
-          end
-          #log_debug {" => #{expanded_value.inspect}"}
-
-          # Otherwise, if the term definition associated to key indicates that it is a reverse property
-          # Spec FIXME: this is not an otherwise.
-          if (td = context.term_definitions[key]) && td.reverse_property
-            # If result has no @reverse member, create one and initialize its value to an empty JSON object.
-            reverse_map = output_object['@reverse'] ||= {}
-            [expanded_value].flatten.each do |item|
-              # If item is a value object or list object, an invalid reverse property value has been detected and processing is aborted.
-              raise JsonLdError::InvalidReversePropertyValue,
-                    item.inspect if value?(item) || list?(item)
-
-              # If reverse map has no expanded property member, create one and initialize its value to an empty array.
-              # Append item to the value of the expanded property member of reverse map.
-              merge_value(reverse_map, expanded_property, item)
-            end
-          else
-            # Otherwise, if key is not a reverse property:
-            # If result does not have an expanded property member, create one and initialize its value to an empty array.
-            (output_object[expanded_property] ||= []).concat([expanded_value].flatten)
+        # See if keys mapping to @type have terms with a local context
+        input.keys.select do |key|
+          context.expand_iri(key, vocab: true) == '@type'
+        end.each do |key|
+          Array(input[key]).each do |term|
+            term_context = context.term_definitions[term].context if context.term_definitions[term]
+            context = term_context ? context.parse(term_context) : context
           end
         end
 
+        # Process each key and value in element. Ignores @nesting content
+        expand_object(input, active_property, context, output_object, ordered: ordered)
+
         #log_debug("output object") {output_object.inspect}
 
         # If result contains the key @value:
@@ -394,5 +125,334 @@ module JSON::LD
       #log_debug {" => #{result.inspect}"}
       result
     end
+
+  private
+    # Expand each key and value of element adding them to result
+    def expand_object(input, active_property, context, output_object, ordered: false)
+      framing = @options[:processingMode].include?("expand-frame")
+      nests = []
+
+      # Then, proceed and process each property and value in element as follows:
+      keys = ordered ? input.keys.kw_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, quiet: true)
+
+        # 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?
+        expanded_property = expanded_property.to_s if expanded_property.is_a?(RDF::Resource)
+
+        #log_debug("expand property") {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
+
+        if expanded_property.nil?
+          #log_debug(" => ") {"skip nil property"}
+          next
+        end
+
+        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'
+
+          # If result has already an expanded property member, 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_value = case expanded_property
+          when '@id'
+            # 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, quiet: true).to_s
+            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, array of string or hash if framing: #{value.inspect}" unless framing
+              context.expand_iri(value, documentRelative: true, quiet: true).to_s
+              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, quiet: true,).to_s
+              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? && framing
+              [{}]
+            else
+              raise JsonLdError::InvalidIdValue,
+                    "value of @id must be a string or hash if framing: #{value.inspect}"
+            end
+
+            # Use array form if framing
+            if framing && !e_id.is_a?(Array)
+              [e_id]
+            else
+              e_id
+            end
+          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
+            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
+              end
+            when String
+              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
+              [{}]
+            else
+              raise JsonLdError::InvalidTypeValue,
+                    "@type value must be a string or array of strings: #{value.inspect}"
+            end
+          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)
+            value.is_a?(Array) ? value : [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 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
+              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
+          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 Array
+              raise JsonLdError::InvalidLanguageTaggedString,
+                    "@language value may not be an array unless framing: #{value.inspect}" unless framing
+              value.map(&:downcase)
+            when Hash
+              raise JsonLdError::InvalidLanguageTaggedString,
+                    "@language value must be a an empty object for framing: #{value.inspect}" unless
+                    value.empty? && framing
+              [value]
+            else
+              raise JsonLdError::InvalidLanguageTaggedString,
+                    "Value of #{expanded_property} must be a string: #{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 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'
+
+            # 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)
+
+            # Spec FIXME: need to be sure that result is an array
+            value = [value] unless value.is_a?(Array)
+
+            # If expanded value is a list object, a list of lists error has been detected and processing is aborted.
+            # Spec FIXME: Also look at each object if result is an array
+            raise JsonLdError::ListOfLists,
+                  "A list may not contain another list" if value.any? {|v| list?(v)}
+
+            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)
+          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,
+                  "@reverse value must be an object: #{value.inspect}" unless value.is_a?(Hash)
+
+            # 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)
+
+            # 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}"}
+              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.
+                (output_object[property] ||= []).concat([item].flatten.compact)
+              end
+            end
+
+            # If expanded value contains members other than @reverse:
+            unless value.keys.reject {|k| k == '@reverse'}.empty?
+              # If result does not have an @reverse member, create one and set its value to an empty JSON object.
+              reverse_map = output_object['@reverse'] ||= {}
+              value.each do |property, items|
+                next if property == '@reverse'
+                items.each do |item|
+                  if value?(item) || list?(item)
+                    raise JsonLdError::InvalidReversePropertyValue,
+                          item.inspect
+                  end
+                  merge_value(reverse_map, property, item)
+                end
+              end
+            end
+
+            # Continue with the next key from element
+            next
+          when '@default', '@embed', '@explicit', '@omitDefault', '@preserve', '@requireAll'
+            next unless framing
+            # Framing keywords
+            [expand(value, expanded_property, context, ordered: ordered)].flatten
+          when '@nest'
+            # Add key to nests
+            nests << key
+            # Continue with the next key from element
+            next
+          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}
+          output_object[expanded_property] = expanded_value unless expanded_value.nil?
+          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 == '@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.
+          ary = []
+
+          # 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|
+            [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,
+                    "Expected #{item.inspect} to be a string" unless item.nil? || item.is_a?(String)
+
+              # Append a JSON object to expanded value that consists of two key-value pairs: (@value-item) and (@language-lowercased language).
+              ary << {
+                '@value' => item,
+                '@language' => k.downcase
+              } if item
+            end
+          end
+
+          ary
+        elsif %w(@index @id @type).include?(container) && value.is_a?(Hash)
+          # Otherwise, if key's container mapping in active context is @index, @id, @type, an IRI or Blank Node and value is a JSON object then value is expanded from an index map as follows:
+          
+          # Set ary to an empty array.
+          container, ary = container.to_s, []
+
+          # 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 is @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 == '@type' && active_context.term_definitions[k]
+            map_context = active_context.parse(map_context) if map_context
+            map_context ||= active_context
+            
+            # 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)
+            #require 'byebug'; byebug
+            index_value.each do |item|
+              case container
+              when '@index' then item[container] ||= k
+              when '@id'
+                # Expand k document relative
+                expanded_k = active_context.expand_iri(k, documentRelative: true, quiet: true).to_s
+                item[container] ||= expanded_k
+              when '@type'
+                # Expand k vocabulary relative
+                expanded_k = active_context.expand_iri(k, vocab: true, documentRelative: true, quiet: true).to_s
+                item[container] = [expanded_k].concat(Array(item[container]))
+              end
+
+              # Append item to expanded value.
+              ary << item
+            end
+          end
+          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)
+        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")
+          next
+        end
+        #log_debug {" => #{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 active_context.container(key) == '@list' && !list?(expanded_value)
+          #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
+          expanded_value = {'@list' => [expanded_value].flatten}
+        end
+        #log_debug {" => #{expanded_value.inspect}"}
+
+        # Otherwise, if the term definition associated to key indicates that it is a reverse property
+        # Spec FIXME: this is not an otherwise.
+        if (td = context.term_definitions[key]) && td.reverse_property
+          # If result has no @reverse member, create one and initialize its value to an empty JSON object.
+          reverse_map = output_object['@reverse'] ||= {}
+          [expanded_value].flatten.each do |item|
+            # If item is a value object or list object, an invalid reverse property value has been detected and processing is aborted.
+            raise JsonLdError::InvalidReversePropertyValue,
+                  item.inspect if value?(item) || list?(item)
+
+            # If reverse map has no expanded property member, create one and initialize its value to an empty array.
+            # Append item to the value of the expanded property member of reverse map.
+            merge_value(reverse_map, expanded_property, item)
+          end
+        else
+          # Otherwise, if key is not a reverse property:
+          # If result does not have an expanded property member, create one and initialize its value to an empty array.
+          (output_object[expanded_property] ||= []).concat([expanded_value].flatten)
+        end
+      end
+
+      # For each key in nests, recusively expand content
+      nests.each do |key|
+        nested_values = input[key]
+        nested_values = [input[key]] unless input[key].is_a?(Array)
+        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)
+        end
+      end
+    end
   end
 end