json-ld 2.2.1 → 3.0.0

data/lib/json/ld/compact.rb

@@ -30,7 +30,8 @@ module JSON::LD
         # If element has a single member and the active property has no
         # @container mapping to @list or @set, the compacted value is that
         # member; otherwise the compacted value is element
-        if result.length == 1 && !context.as_array?(property) && @options[:compactArrays]
+        if result.length == 1 &&
+           !context.as_array?(property) && @options[:compactArrays]
           #log_debug("=> extract single element: #{result.first.inspect}")
           result.first
         else
@@ -51,26 +52,34 @@ module JSON::LD
           end
         end
 
+        # If expanded property is @list and we're contained within a list container, recursively compact this item to an array
+        if list?(element) && context.container(property) == %w(@list)
+          return compact(element['@list'], property: property)
+        end
+
+
         inside_reverse = property == '@reverse'
         result, nest_result = {}, nil
 
+        # Apply any context defined on an alias of @type
+        # If key is @type and any compacted value is a term having a local context, overlay that context.
+        Array(element['@type']).
+          map {|expanded_type| context.compact_iri(expanded_type, vocab: true)}.
+          sort.
+          each do |term|
+          term_context = self.context.term_definitions[term].context if context.term_definitions[term]
+          self.context = context.parse(term_context) if term_context
+        end
+
         element.keys.sort.each do |expanded_property|
           expanded_value = element[expanded_property]
           #log_debug("") {"#{expanded_property}: #{expanded_value.inspect}"}
 
           if expanded_property == '@id' || expanded_property == '@type'
-            compacted_value = [expanded_value].flatten.compact.map do |expanded_type|
+            compacted_value = Array(expanded_value).map do |expanded_type|
               context.compact_iri(expanded_type, vocab: (expanded_property == '@type'), log_depth: @options[:log_depth])
             end
 
-            # If key is @type and any compacted value is a term having a local context, overlay that context.
-            if expanded_property == '@type'
-              compacted_value.each do |term|
-                term_context = self.context.term_definitions[term].context if context.term_definitions[term]
-                self.context = context.parse(term_context) if term_context
-              end
-            end
-
             compacted_value = compacted_value.first if compacted_value.length == 1
 
             al = context.compact_iri(expanded_property, vocab: true, quiet: true)
@@ -85,11 +94,8 @@ module JSON::LD
             # handle double-reversed properties
             compacted_value.each do |prop, value|
               if context.reverse?(prop)
-                value = [value] if !value.is_a?(Array) &&
-                  (context.as_array?(prop) || !@options[:compactArrays])
-                #log_debug("") {"merge #{prop} => #{value.inspect}"}
-
-                merge_compacted_value(result, prop, value)
+                add_value(result, prop, value,
+                  property_is_array: context.as_array?(prop) || !@options[:compactArrays])
                 compacted_value.delete(prop)
               end
             end
@@ -136,11 +142,11 @@ module JSON::LD
 
             if nest_prop = context.nest(item_active_property)
               result[nest_prop] ||= {}
-              iap = result[result[nest_prop]] ||= []
-              result[nest_prop][item_active_property] = [iap] unless iap.is_a?(Array)
+              add_value(result[nest_prop], item_active_property, [],
+                property_is_array: true)
             else
-              iap = result[item_active_property] ||= []
-              result[item_active_property] = [iap] unless iap.is_a?(Array)
+              add_value(result, item_active_property, [],
+                property_is_array: true)
             end
           end
 
@@ -162,7 +168,7 @@ module JSON::LD
             end
 
             container = context.container(item_active_property)
-            as_array = context.as_array?(item_active_property)
+            as_array = !@options[:compactArrays] || context.as_array?(item_active_property)
 
             value = case
             when list?(expanded_item) then expanded_item['@list']
@@ -175,7 +181,7 @@ module JSON::LD
 
             # handle @list
             if list?(expanded_item)
-              compacted_item = [compacted_item] unless compacted_item.is_a?(Array)
+              compacted_item = as_array(compacted_item)
               unless container == %w(@list)
                 al = context.compact_iri('@list', vocab: true, quiet: true)
                 compacted_item = {al => compacted_item}
@@ -184,36 +190,35 @@ module JSON::LD
                   compacted_item[key] = expanded_item['@index']
                 end
               else
-                raise JsonLdError::CompactionToListOfLists,
-                      "key cannot have more than one list value" if nest_result.has_key?(item_active_property)
-              # Falls through to add list value below
+                add_value(nest_result, item_active_property, compacted_item,
+                  value_is_array: true, allow_duplicate: true)
+                  next
               end
             end
 
             # Graph object compaction cases:
             if graph?(expanded_item)
-              if container.include?('@graph') && container.include?('@id')
+              if container.include?('@graph') &&
+                (container.include?('@id') || container.include?('@index') && simple_graph?(expanded_item))
                 # container includes @graph and @id
                 map_object = nest_result[item_active_property] ||= {}
-                map_key = expanded_item['@id']
                 # If there is no @id, create a blank node identifier to use as an index
-                map_key = map_key ? context.compact_iri(map_key, quiet: true) : namer.get_name
-                merge_compacted_value(map_object, map_key, compacted_item)
-              elsif container.include?('@graph') && container.include?('@index') && simple_graph?(expanded_item)
-                # container includes @graph and @index and value is a simple graph object
-                map_object = nest_result[item_active_property] ||= {}
-                # If there is no @index, use @none
-                map_key = expanded_item['@index'] || '@none'
-                merge_compacted_value(map_object, map_key, compacted_item)
+                map_key = if container.include?('@id') && expanded_item['@id']
+                  context.compact_iri(expanded_item['@id'], quiet: true)
+                elsif container.include?('@index') && expanded_item['@index']
+                  context.compact_iri(expanded_item['@index'], quiet: true)
+                else
+                  context.compact_iri('@none', vocab: true, quiet: true)
+                end
+                add_value(map_object, map_key, compacted_item,
+                  property_is_array: as_array)
               elsif container.include?('@graph') && simple_graph?(expanded_item)
                 # container includes @graph but not @id or @index and value is a simple graph object
                 # Drop through, where compacted_value will be added
-                compacted_item = [compacted_item] if
-                  !compacted_item.is_a?(Array) && (!@options[:compactArrays] || as_array)
-                merge_compacted_value(nest_result, item_active_property, compacted_item)
+                add_value(nest_result, item_active_property, compacted_item,
+                  property_is_array: as_array)
               else
                 # container does not include @graph or otherwise does not match one of the previous cases, redo compacted_item
-                compacted_item = [compacted_item]
                 al = context.compact_iri('@graph', vocab: true, quiet: true)
                 compacted_item = {al => compacted_item}
                 if expanded_item['@id']
@@ -224,47 +229,46 @@ module JSON::LD
                   key = context.compact_iri('@index', vocab: true, quiet: true)
                   compacted_item[key] = expanded_item['@index']
                 end
-                compacted_item = [compacted_item] if !@options[:compactArrays] || as_array
-                merge_compacted_value(nest_result, item_active_property, compacted_item)
+                add_value(nest_result, item_active_property, compacted_item,
+                  property_is_array: as_array)
               end
             elsif !(container & %w(@language @index @id @type)).empty? && !container.include?('@graph')
               map_object = nest_result[item_active_property] ||= {}
+              c = container.first
+              container_key = context.compact_iri(c, vocab: true, quiet: true)
               compacted_item = case container
               when %w(@id)
-                id_prop = context.compact_iri('@id', vocab: true, quiet: true)
-                map_key = compacted_item[id_prop]
-                map_key = context.compact_iri(map_key, quiet: true)
-                compacted_item.delete(id_prop)
+                map_key = compacted_item[container_key]
+                compacted_item.delete(container_key)
                 compacted_item
               when %w(@index)
                 map_key = expanded_item['@index']
+                compacted_item.delete(container_key) if compacted_item.is_a?(Hash)
                 compacted_item
               when %w(@language)
                 map_key = expanded_item['@language']
                 value?(expanded_item) ? expanded_item['@value'] : compacted_item
               when %w(@type)
-                type_prop = context.compact_iri('@type', vocab: true, quiet: true)
-                map_key, *types = Array(compacted_item[type_prop])
-                map_key = context.compact_iri(map_key, vocab: true, quiet: true)
+                map_key, *types = Array(compacted_item[container_key])
                 case types.length
-                when 0 then compacted_item.delete(type_prop)
-                when 1 then compacted_item[type_prop] = types.first
-                else        compacted_item[type_prop] = types
+                when 0 then compacted_item.delete(container_key)
+                when 1 then compacted_item[container_key] = types.first
+                else        compacted_item[container_key] = types
                 end
                 compacted_item
               end
-              compacted_item = [compacted_item] if as_array && !compacted_item.is_a?(Array)
-              merge_compacted_value(map_object, map_key, compacted_item)
+              map_key ||= context.compact_iri('@none', vocab: true, quiet: true)
+              add_value(map_object, map_key, compacted_item,
+                property_is_array: as_array)
             else
-              compacted_item = [compacted_item] if
-                !compacted_item.is_a?(Array) && (!@options[:compactArrays] || as_array)
-              merge_compacted_value(nest_result, item_active_property, compacted_item)
+              add_value(nest_result, item_active_property, compacted_item,
+                property_is_array: as_array)
             end
           end
         end
 
         # Re-order result keys
-        result.keys.kw_sort.each_with_object({}) {|kk, memo| memo[kk] = result[kk]}
+        result.keys.sort.each_with_object({}) {|kk, memo| memo[kk] = result[kk]}
       else
         # For other types, the compacted value is the element value
         #log_debug("compact") {element.class.to_s}

data/lib/json/ld/context.rb

@@ -336,15 +336,15 @@ module JSON::LD
     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.
+    # If processingMode has been set, and it is not "json-ld-1.1", 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")
+        if processingMode && processingMode < "json-ld-1.1"
           raise JsonLdError::ProcessingModeConflict, "#{value} not compatible with #{processingMode}"
         end
-        @processingMode ||= "json-ld-1.1"
+        @processingMode = "json-ld-1.1"
       else
         raise JsonLdError::InvalidVersionValue, value
       end
@@ -357,13 +357,13 @@ module JSON::LD
       when /_:/
         value
       when String, RDF::URI
-        v = as_resource(value.to_s)
-        raise JsonLdError::InvalidVocabMapping, "@vocab must be an absolute IRI: #{value.inspect}" if v.uri? && v.relative? && @options[:validate]
+        v = as_resource(value.to_s, base)
+        raise JsonLdError::InvalidVocabMapping, "@vocab must be an IRI: #{value.inspect}" if !v.valid? && @options[:validate]
         v
       when nil
         nil
       else
-        raise JsonLdError::InvalidVocabMapping, "@vocab must be an absolute IRI: #{value.inspect}"
+        raise JsonLdError::InvalidVocabMapping, "@vocab must be an IRI: #{value.inspect}"
       end
     end
 
@@ -385,7 +385,7 @@ module JSON::LD
       result = self.dup
       result.provided_context = local_context if self.empty?
 
-      local_context = [local_context] unless local_context.is_a?(Array)
+      local_context = as_array(local_context)
 
       local_context.each do |context|
         case context
@@ -419,6 +419,7 @@ module JSON::LD
 
           raise JsonLdError::RecursiveContextInclusion, "#{context}" if remote_contexts.include?(context.to_s)
           remote_contexts << context.to_s
+          raise JsonLdError::ContextOverflow, "#{context}" if remote_contexts.length >= MAX_CONTEXTS_LOADED
 
           context_no_base = result.dup
           context_no_base.base = nil
@@ -448,9 +449,6 @@ module JSON::LD
                 end
                 raise JsonLdError::InvalidRemoteContext, "#{context}" unless jo.is_a?(Hash) && jo.has_key?('@context')
                 context = jo['@context']
-                if  (processingMode || 'json-ld-1.0') <= "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}"}
@@ -464,6 +462,7 @@ module JSON::LD
 
             # 3.2.6) Set context to the result of recursively calling this algorithm, passing context no base for active context, context for local context, and remote contexts.
             context = context_no_base.parse(context, remote_contexts.dup)
+            PRELOADED[context_canon.to_s] = context
             context.provided_context = result.provided_context
           end
           context.base ||= result.base
@@ -486,11 +485,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
+
+          # 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|
             result.create_term_definition(context, key, defined)
           end
@@ -651,10 +648,10 @@ module JSON::LD
           raise JsonLdError::InvalidKeywordAlias, "expected value of @id to not be @context on term #{term.inspect}" if
             definition.id == '@context'
 
-            # If id ends with a gen-delim, it may be used as a prefix
-            definition.prefix = true if !term.include?(':') &&
-              definition.id.to_s.end_with?(*%w(: / ? # [ ] @)) &&
-              (simple_term || ((processingMode || 'json-ld-1.0') == 'json-ld-1.0'))
+          # If id ends with a gen-delim, it may be used as a prefix for simple terms
+          definition.prefix = true if !term.include?(':') &&
+            definition.id.to_s.end_with?(*%w(: / ? # [ ] @)) &&
+            simple_term
         elsif term.include?(':')
           # If term is a compact IRI with a prefix that is a key in local context then a dependency has been found. Use this algorithm recursively passing active context, local context, the prefix as term, and defined.
           prefix, suffix = term.split(':', 2)
@@ -735,7 +732,7 @@ module JSON::LD
     #
     # @param  [Hash{Symbol => Object}] options ({})
     # @return [Hash]
-    def serialize(options = {})
+    def serialize(**options)
       # FIXME: not setting provided_context now
       use_context = case provided_context
       when String, RDF::URI
@@ -994,8 +991,14 @@ module JSON::LD
         create_term_definition(local_context, value, defined)
       end
 
+      if (v_td = term_definitions[value]) && KEYWORDS.include?(v_td.id)
+        #log_debug("") {"match with #{v_td.id}"} unless quiet
+        return v_td.id
+      end
+
+      # If active context has a term definition for value, and the associated mapping is a keyword, return that keyword.
       # If vocab is true and the active context has a term definition for value, return the associated IRI mapping.
-      if vocab && (v_td = term_definitions[value])
+      if (v_td = term_definitions[value]) && (vocab || KEYWORDS.include?(v_td.id))
         #log_debug("") {"match with #{v_td.id}"} unless quiet
         return v_td.id
       end
@@ -1030,7 +1033,7 @@ module JSON::LD
       result = if vocab && self.vocab
         # If vocab is true, and active context has a vocabulary mapping, return the result of concatenating the vocabulary mapping with value.
         self.vocab + value
-      elsif documentRelative && (base ||= self.base)
+      elsif (documentRelative || self.vocab == '') && (base ||= self.base)
         # Otherwise, if document relative is true, set value to the result of resolving value against the base IRI. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [RFC3987].
         value = RDF::URI(value)
         value.absolute? ? value : RDF::URI(base).join(value)
@@ -1069,15 +1072,11 @@ module JSON::LD
         default_language = self.default_language || "@none"
         containers = []
         tl, tl_value = "@language", "@null"
+        containers.concat(%w(@index @index@set)) if index?(value) && !graph?(value)
 
         # If the value is a JSON Object with the key @preserve, use the value of @preserve.
         value = value['@preserve'].first if value.is_a?(Hash) && value.has_key?('@preserve')
 
-        # 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'
@@ -1123,20 +1122,30 @@ module JSON::LD
           end
           #log_debug("") {"list: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless quiet
         elsif graph?(value)
-          # TODO: support `@graphId`?
-          # TODO: "@graph@set"?
-          containers << '@graph'
-          containers << '@set'
+          # Prefer @index and @id containers, then @graph, then @index
+          containers.concat(%w(@graph@index @graph@index@set @index @index@set)) if index?(value)
+          containers.concat(%w(@graph@id @graph@id@set)) if value.has_key?('@id')
+
+          # Prefer an @graph container next
+          containers.concat(%w(@graph @graph@set @set))
+
+          # Lastly, in 1.1, any graph can be indexed on @index or @id, so add if we haven't already
+          containers.concat(%w(@graph@index @graph@index@set)) unless index?(value)
+          containers.concat(%w(@graph@id @graph@id@set)) unless value.has_key?('@id')
+          containers.concat(%w(@index @index@set)) unless index?(value)
         else
           if value?(value)
+            # In 1.1, an language map can be used to index values using @none
             if value.has_key?('@language') && !index?(value)
               tl_value = value['@language']
-              containers << '@language'
+              containers.concat(%w(@language @language@set))
             elsif value.has_key?('@type')
               tl_value = value['@type']
               tl = '@type'
             end
           else
+            # In 1.1, an id or type map can be used to index values using @none
+            containers.concat(%w(@id @id@set @type @set@type))
             tl, tl_value = '@type', '@id'
           end
           containers << '@set'
@@ -1144,6 +1153,12 @@ module JSON::LD
         end
 
         containers << '@none'
+
+        # In 1.1, an index map can be used to index values using @none, so add as a low priority
+        containers.concat(%w(@index @index@set)) unless index?(value)
+        # Values without type or language can use @language map
+        containers.concat(%w(@language @language@set)) if value?(value) && value.keys == %w(@value)
+
         tl_value ||= '@null'
         preferred_values = []
         preferred_values << '@reverse' if tl_value == '@reverse'
@@ -1306,7 +1321,7 @@ module JSON::LD
     # @raise [JsonLdError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-compaction
     # FIXME: revisit the specification version of this.
-    def compact_value(property, value, options = {})
+    def compact_value(property, value, **options)
       #log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
       num_members = value.length
@@ -1521,14 +1536,11 @@ module JSON::LD
         end.each do |term|
           next unless td = term_definitions[term]
 
-          container = Array(td.container_mapping).sort.first
-          container ||= td.as_set? ? %(@set) : %(@none)
-          # FIXME: Alternative to consider
-          ## Creates "@language", "@language@set", "@set", or "@none"
-          ## for each of "@language", "@index", "@type", "@id", "@list", and "@graph"
-          #container = td.container_mapping.to_s
-          #container += '@set' if td.as_set?
-          #container = '@none' if container.empty?
+          container = td.container_mapping.join('')
+          if container.empty?
+            container = td.as_set? ? %(@set) : %(@none)
+          end
+
           container_map = result[td.id.to_s] ||= {}
           tl_map = container_map[container] ||= {'@language' => {}, '@type' => {}, '@any' => {}}
           type_map = tl_map['@type']

data/lib/json/ld/expand.rb

@@ -16,22 +16,23 @@ module JSON::LD
     # @param [Context] context
     # @param [Boolean] ordered (true)
     #   Ensure output objects have keys ordered properly
+    # @param [Boolean] framing (false)
+    #   Special rules for expanding a frame
     # @return [Array<Hash{String => Object}>]
-    def expand(input, active_property, context, ordered: true)
-      framing = @options[:processingMode].include?("expand-frame")
+    def expand(input, active_property, context, ordered: true, framing: false)
       #log_debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
+      framing = false if active_property == '@default'
       result = case input
       when Array
         # If element is an array,
         is_list = context.container(active_property) == %w(@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)
+          v = expand(v, active_property, context, ordered: ordered, framing: framing)
+
+          # 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 the active property is @list or its container mapping is set to @list, the expanded item must not be an array or a list object, otherwise a list of lists error has been detected and processing is aborted.
-          raise JsonLdError::ListOfLists,
-                "A list may not contain another list" if
-                is_list && (v.is_a?(Array) || list?(v))
           case v
           when nil then nil
           when Array then memo.concat(v)
@@ -52,14 +53,14 @@ module JSON::LD
         # 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).each do |term|
+          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
           end
         end
 
         # Process each key and value in element. Ignores @nesting content
-        expand_object(input, active_property, context, output_object, ordered: ordered)
+        expand_object(input, active_property, context, output_object, ordered: ordered, framing: framing)
 
         #log_debug("output object") {output_object.inspect}
 
@@ -83,8 +84,8 @@ module JSON::LD
             # 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.fetch('@type', "")).all? {|t|
-                  t.is_a?(String) && context.expand_iri(t, vocab: true, log_depth: @options[:log_depth]).is_a?(RDF::URI) ||
+          elsif !Array(output_object['@type']).all? {|t|
+                  t.is_a?(String) && RDF::URI(t).absolute? && !t.start_with?('_:') ||
                   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,
@@ -117,7 +118,7 @@ module JSON::LD
 
         # Re-order result keys if ordering
         if ordered
-          output_object.keys.kw_sort.each_with_object({}) {|kk, memo| memo[kk] = output_object[kk]}
+          output_object.keys.sort.each_with_object({}) {|kk, memo| memo[kk] = output_object[kk]}
         else
           output_object
         end
@@ -135,12 +136,11 @@ module JSON::LD
     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: false)
-      framing = @options[:processingMode].include?("expand-frame")
+    def expand_object(input, active_property, context, output_object, ordered:, framing:)
       nests = []
 
       # Then, proceed and process each property and value in element as follows:
-      keys = ordered ? input.keys.kw_sort : input.keys
+      keys = ordered ? input.keys.sort : input.keys
       keys.each do |key|
         # For each key and value in element, ordered lexicographically by key:
         value = input[key]
@@ -195,8 +195,8 @@ module JSON::LD
             end
 
             # Use array form if framing
-            if framing && !e_id.is_a?(Array)
-              [e_id]
+            if framing
+              as_array(e_id)
             else
               e_id
             end
@@ -224,8 +224,8 @@ module JSON::LD
             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]
+            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 framing, always use array form, unless null
@@ -277,20 +277,15 @@ module JSON::LD
             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)
+            value = expand(value, active_property, context, ordered: ordered, framing: framing)
 
             # 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 = as_array(value)
 
             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)
+            expand(value, active_property, context, ordered: ordered, framing: framing)
           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,
@@ -298,7 +293,7 @@ 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)
+            value = expand(value, '@reverse', context, ordered: ordered, framing: framing)
 
             # 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')
@@ -331,7 +326,7 @@ module JSON::LD
           when '@default', '@embed', '@explicit', '@omitDefault', '@preserve', '@requireAll'
             next unless framing
             # Framing keywords
-            [expand(value, expanded_property, context, ordered: ordered)].flatten
+            [expand(value, expanded_property, context, ordered: ordered, framing: framing)].flatten
           when '@nest'
             # Add key to nests
             nests << key
@@ -361,16 +356,16 @@ 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
             [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
+              v = {'@value' => item}
+              v['@language'] = k.downcase unless expanded_k == '@none'
+              ary << v if item
             end
           end
 
@@ -388,30 +383,29 @@ module JSON::LD
             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
-            
+
+            expanded_k = active_context.expand_iri(k, vocab: true, quiet: true).to_s
+
             # Initialize index value to the result of using this algorithm recursively, passing active context, key as active property, and index value as element.
-            index_value = expand([value[k]].flatten, key, map_context, ordered: ordered)
+            index_value = expand([value[k]].flatten, key, map_context, ordered: ordered, framing: framing)
             index_value.each do |item|
               case container
-              when %w(@index) then item['@index'] ||= k
-              when %w(@id)
-                # Expand k document relative
-                expanded_k = active_context.expand_iri(k, documentRelative: true, quiet: true).to_s
-                item['@id'] ||= expanded_k
-              when %w(@type)
-                # Expand k vocabulary relative
-                expanded_k = active_context.expand_iri(k, vocab: true, documentRelative: true, quiet: true).to_s
-                item['@type'] = [expanded_k].concat(Array(item['@type']))
-              when %w(@graph @index), %w(@graph @id)
+              when %w(@graph @index), %w(@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)
                 # Indexed graph by graph name
-                if !graph?(item)
-                  item = [item] unless expanded_value.is_a?(Array)
-                  item = {'@graph' => item}
+                if !graph?(item) && container.include?('@graph')
+                  item = {'@graph' => as_array(item)}
                 end
-                expanded_k = container.include?('@index') ? k :
-                  active_context.expand_iri(k, documentRelative: true, quiet: true).to_s
                 # Expand k document relative
-                item[container.include?('@index') ? '@index' : '@id'] ||= k
+                expanded_k = active_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)
+                item['@type'] = [expanded_k].concat(Array(item['@type'])) unless expanded_k == '@none'
               end
 
               # Append item to expanded value.
@@ -421,7 +415,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)
+          expand(value, key, active_context, ordered: ordered, framing: framing)
         end
 
         # If expanded value is null, ignore key by continuing to the next key from element.
@@ -434,17 +428,16 @@ module JSON::LD
         # 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) == %w(@list) && !list?(expanded_value)
           #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
-          expanded_value = [expanded_value] unless expanded_value.is_a?(Array)
-          expanded_value = {'@list' => expanded_value}
+          expanded_value = {'@list' => as_array(expanded_value)}
         end
         #log_debug {" => #{expanded_value.inspect}"}
 
         # convert expanded value to @graph if container specifies it
-        # FIXME value may be a named graph, as well as a simple graph.
-        if active_context.container(key) == %w(@graph) && !graph?(expanded_value)
+        if active_context.container(key) == %w(@graph)
           #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
-          expanded_value = [expanded_value] unless expanded_value.is_a?(Array)
-          expanded_value = {'@graph' => expanded_value}
+          expanded_value = as_array(expanded_value).map do |v|
+            graph?(v) ? v : {'@graph' => as_array(v)}
+          end
         end
 
         # Otherwise, if the term definition associated to key indicates that it is a reverse property
@@ -470,12 +463,11 @@ module JSON::LD
 
       # 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 = as_array(input[key])
         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)
+          expand_object(nv, active_property, context, output_object, ordered: ordered, framing: framing)
         end
       end
     end