json-ld 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 693e380cfc75c04525a1144d742a4c98737df5bf
-  data.tar.gz: a6d0d85e8323532379bfeef2be95361b1a5c1a01
+  metadata.gz: cb9297e31b76d1e901ae278f349ed412086831f5
+  data.tar.gz: e07e7aeb8bb57349e5f819da903fb55524c46b43
 SHA512:
-  metadata.gz: d18d9ad16dc730a96037c4b5f8b1926910d75820a94529a1287fe82dcc1e251b1c73fce936ba3988c6672f5615e8361298971018d24525ce51dd1c2667062492
-  data.tar.gz: 34cfa1b4561de877b8eb94513a42c8c383f8ce037a03c67f9535cbd1a71ed4a9023e71a70a7ba8bb79b73c7c9e49827d664028af416a7f1b489f25a3dd821e8d
+  metadata.gz: 7baea9184fa7cea017a37cb7ec2aa2a4a4b18e153b6a771a8b5297bfe518ca669a66e9a84dc5e37dd04e1b135653ff9195f4b6fb56d48af1a835f1290f8862dd
+  data.tar.gz: fba430dad035dd6465e07ee94c952bf79c33be220baa642a57e07c8d21cd7aa3431e824c5487c3f3b43f4a23f7b30f55c62d059e4b6fb5c2ff1ac8828932b86e

data/VERSION

@@ -1 +1 @@
-2.1.0
+2.1.1

data/lib/json/ld.rb

@@ -47,7 +47,6 @@ module JSON
       @context
       @default
       @embed
-      @embedChildren
       @explicit
       @id
       @index
@@ -55,6 +54,7 @@ module JSON
       @language
       @list
       @omitDefault
+      @requireAll
       @reverse
       @set
       @type

data/lib/json/ld/api.rb

@@ -70,8 +70,10 @@ module JSON::LD
     #   A context that is used to initialize the active context when expanding a document.
     # @option options [Boolean, String, RDF::URI] :flatten
     #   If set to a value that is not `false`, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of `flatten must` be either an _IRI_ value representing the name of the graph to flatten, or `true`. If the value is `true`, then the first graph encountered in the input document is selected and flattened.
-    # @option options [String] :processingMode ("json-ld-1.0")
-    #   If set to "json-ld-1.0", the JSON-LD processor must produce exactly the same results as the algorithms defined in this specification. If set to another value, the JSON-LD processor is allowed to extend or modify the algorithms defined in this specification to enable application-specific optimizations. The definition of such optimizations is beyond the scope of this specification and thus not defined. Consequently, different implementations may implement different optimizations. Developers must not define modes beginning with json-ld as they are reserved for future versions of this specification.
+    # @option options [String] :processingMode ("json-ld-1.1")
+    #   Processing mode, json-ld-1.0 or json-ld-1.1. Also can have other values:
+    #
+    #   * json-ld-1.1-expand-frame – special frame expansion mode.
     # @option options [Boolean] :rename_bnodes (true)
     #   Rename bnodes as part of expansion, or keep them the same.
     # @option options [Boolean]  :unique_bnodes   (false)
@@ -84,9 +86,14 @@ module JSON::LD
     # @yieldparam [API]
     # @raise [JsonLdError]
     def initialize(input, context, options = {}, &block)
-      @options = {compactArrays: true, rename_bnodes: true}.merge!(options)
-      @options[:validate] = true if @options[:processingMode] == "json-ld-1.0"
-      @options[:documentLoader] ||= self.class.method(:documentLoader)
+      @options = {
+        compactArrays: true,
+        rename_bnodes: true,
+        processingMode: "json-ld-1.1",
+        documentLoader: self.class.method(:documentLoader)
+      }
+      @options[:validate] = %w(json-ld-1.0 json-ld-1.1).include?(@options[:processingMode])
+      @options = @options.merge(options)
       @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
       # For context via Link header
@@ -127,8 +134,7 @@ module JSON::LD
 
       # If not provided, first use context from document, or from a Link header
       context ||= (@value['@context'] if @value.is_a?(Hash)) || context_ref
-      @context = Context.new(@options)
-      @context = @context.parse(context) if context
+      @context = Context.parse(context || {}, @options)
 
       if block_given?
         case block.arity
@@ -150,9 +156,7 @@ module JSON::LD
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to copy and perform the expansion upon.
     # @param  [Hash{Symbol => Object}] options
-    #   See options in {JSON::LD::API#initialize}
-    # @option options [String, #read, Hash, Array, JSON::LD::Context] :expandContext
-    #   A context that is used to initialize the active context when expanding a document.
+    # @option options (see #initialize)
     # @raise [JsonLdError]
     # @yield jsonld
     # @yieldparam [Array<Hash>] jsonld
@@ -164,10 +168,7 @@ module JSON::LD
     def self.expand(input, options = {})
       result = nil
       API.new(input, options[:expandContext], options) do |api|
-        result = api.expand(api.value, nil, api.context,
-                            ordered: options.fetch(:ordered, true),
-                            framing: options.fetch(:framing, false),
-                            keep_free_floating_nodes: options.fetch(:keep_free_floating_nodes, false))
+        result = api.expand(api.value, nil, api.context, ordered: options.fetch(:ordered, true))
       end
 
       # If, after the algorithm outlined above is run, the resulting element is an
@@ -192,8 +193,7 @@ module JSON::LD
     # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   The base context to use when compacting the input.
     # @param  [Hash{Symbol => Object}] options
-    #   See options in {JSON::LD::API#initialize}
-    #   Other options passed to {JSON::LD::API.expand}
+    # @option options (see #initialize)
     # @option options [Boolean] :expanded Input is already expanded
     # @yield jsonld
     # @yieldparam [Hash] jsonld
@@ -212,7 +212,7 @@ module JSON::LD
 
       API.new(expanded_input, context, options) do
         log_debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE) rescue 'malformed json'}"}
-        result = compact(value, nil)
+        result = compact(value)
 
         # xxx) Add the given context to the output
         ctx = self.context.serialize
@@ -235,8 +235,7 @@ module JSON::LD
     # @param [String, #read, Hash, Array, JSON::LD::EvaluationContext] context
     #   An optional external context to use additionally to the context embedded in input when expanding the input.
     # @param  [Hash{Symbol => Object}] options
-    #   See options in {JSON::LD::API#initialize}
-    #   Other options passed to {JSON::LD::API.expand}
+    # @option options (see #initialize)
     # @option options [Boolean] :expanded Input is already expanded
     # @yield jsonld
     # @yieldparam [Hash] jsonld
@@ -256,12 +255,12 @@ module JSON::LD
         log_debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
-        graphs = {'@default' => {}}
-        create_node_map(value, graphs)
+        graph_maps = {'@default' => {}}
+        create_node_map(value, graph_maps)
 
-        default_graph = graphs['@default']
-        graphs.keys.kw_sort.reject {|k| k == '@default'}.each do |graph_name|
-          graph = graphs[graph_name]
+        default_graph = graph_maps['@default']
+        graph_maps.keys.kw_sort.reject {|k| k == '@default'}.each do |graph_name|
+          graph = graph_maps[graph_name]
           entry = default_graph[graph_name] ||= {'@id' => graph_name}
           nodes = entry['@graph'] ||= []
           graph.keys.kw_sort.each do |id|
@@ -274,7 +273,7 @@ module JSON::LD
 
         if context && !flattened.empty?
           # Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result uses the @graph keyword (or its alias) at the top-level, even if the context is empty or if there is only one element to put in the @graph array. This ensures that the returned document has a deterministic structure.
-          compacted = compact(flattened, nil)
+          compacted = compact(flattened)
           compacted = [compacted] unless compacted.is_a?(Array)
           kwgraph = self.context.compact_iri('@graph', quiet: true)
           flattened = self.context.serialize.merge(kwgraph => compacted)
@@ -295,9 +294,7 @@ module JSON::LD
     #   The JSON-LD object to copy and perform the framing on.
     # @param [String, #read, Hash, Array] frame
     #   The frame to use when re-arranging the data.
-    # @param  [Hash{Symbol => Object}] options
-    #   See options in {JSON::LD::API#initialize}
-    #   Other options passed to {JSON::LD::API.expand}
+    # @option options (see #initialize)
     # @option options ['@last', '@always', '@never', '@link'] :embed ('@last')
     #   a flag specifying that objects should be directly embedded in the output,
     #   instead of being referred to by their IRI.
@@ -305,6 +302,9 @@ module JSON::LD
     #   a flag specifying that for properties to be included in the output,
     #   they must be explicitly declared in the framing context.
     # @option options [Boolean] :requireAll (true)
+    #   A flag specifying that all properties present in the input frame must
+    #   either have a default value or be present in the JSON-LD input for the
+    #   frame to match.
     # @option options [Boolean] :omitDefault (false)
     #   a flag specifying that properties that are missing from the JSON-LD
     #   input should be omitted from the output.
@@ -330,7 +330,8 @@ module JSON::LD
       }.merge!(options)
 
       framing_state = {
-        graphs:       {'@default' => {}, '@merged' => {}},
+        graphMap:     {},
+        graphStack:   [],
         subjectStack: [],
         link:         {},
       }
@@ -351,17 +352,27 @@ module JSON::LD
       expanded_input = options[:expanded] ? input : API.expand(input, options)
 
       # Expand frame to simplify processing
-      expanded_frame = API.expand(frame, options.merge(framing: true, keep_free_floating_nodes: true))
+      expanded_frame = API.expand(frame, options.merge(processingMode: "json-ld-1.1-expand-frame"))
 
       # Initialize input using frame as context
       API.new(expanded_input, nil, options) do
         log_debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
-        old_logger, @options[:logger] = @options[:logger], []
-        create_node_map(value, framing_state[:graphs], graph: '@merged')
-        @options[:logger] = old_logger
-        framing_state[:subjects] = framing_state[:graphs]['@merged']
+        create_node_map(value, framing_state[:graphMap], graph: '@default')
+
+        frame_keys = frame.keys.map {|k| context.expand_iri(k, vocab: true, quiet: true)}
+        if frame_keys.include?('@graph')
+          # If frame contains @graph, it matches the default graph.
+          framing_state[:graph] = '@default'
+        else
+          # If frame does not contain @graph used the merged graph.
+          framing_state[:graph] = '@merged'
+          framing_state[:link]['@merged'] = {}
+          framing_state[:graphMap]['@merged'] = merge_node_map_graphs(framing_state[:graphMap])
+        end
+
+        framing_state[:subjects] = framing_state[:graphMap][framing_state[:graph]]
 
         result = []
         frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), options.merge(parent: result))
@@ -369,7 +380,7 @@ module JSON::LD
         # Initalize context from frame
         @context = @context.parse(frame['@context'])
         # Compact result
-        compacted = compact(result, nil)
+        compacted = compact(result)
         compacted = [compacted] unless compacted.is_a?(Array)
 
         # Add the given context to the output
@@ -387,9 +398,7 @@ module JSON::LD
     #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to process when outputting statements.
-    # @param [{Symbol,String => Object}] options
-    #   See options in {JSON::LD::API#initialize}
-    #   Options passed to {JSON::LD::API.expand}
+    # @option options (see #initialize)
     # @option options [Boolean] :produceGeneralizedRdf (false)
     #   If true, output will include statements having blank node predicates, otherwise they are dropped.
     # @option options [Boolean] :expanded Input is already expanded
@@ -449,7 +458,7 @@ module JSON::LD
     #
     # @param [Array<RDF::Statement>] input
     # @param  [Hash{Symbol => Object}] options
-    #   See options in {JSON::LD::API#initialize}
+    # @option options (see #initialize)
     # @option options [Boolean] :useRdfType (false)
     #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
     # @yield jsonld
@@ -488,7 +497,7 @@ module JSON::LD
         # If the passed input is a DOMString representing the IRI of a remote document, dereference it. If the retrieved document's content type is neither application/json, nor application/ld+json, nor any other media type using a +json suffix as defined in [RFC6839], reject the promise passing an loading document failed error.
         if content_type && options[:validate]
           main, sub = content_type.split("/")
-          raise JSON::LD::JsonLdError::LoadingDocumentFailed, "content_type: #{content_type}" if
+          raise JSON::LD::JsonLdError::LoadingDocumentFailed, "url: #{url}, content_type: #{content_type}" if
             main != 'application' ||
             sub !~ /^(.*\+)?json$/
         end
@@ -523,10 +532,6 @@ module JSON::LD
     def validate_input(input)
       return unless defined?(JsonLint)
       jsonlint = JsonLint::Linter.new
-      unless jsonlint.respond_to?(:check_stream)
-        warn "Skipping jsonlint, use latest version from GiHub until 0.1.1 released"
-        return
-      end
       input = StringIO.new(input) unless input.respond_to?(:read)
       unless jsonlint.check_stream(input)
         raise JsonLdError::LoadingDocumentFailed, jsonlint.errors[''].join("\n")

data/lib/json/ld/compact.rb

@@ -10,7 +10,7 @@ module JSON::LD
     # @param [Array, Hash] element
     # @param [String] property (nil)
     # @return [Array, Hash]
-    def compact(element, property = nil)
+    def compact(element, property: nil)
       #if property.nil?
       #  log_debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
       #else
@@ -19,7 +19,7 @@ module JSON::LD
       case element
       when Array
         #log_debug("") {"Array #{element.inspect}"}
-        result = element.map {|item| compact(item, property)}.compact
+        result = element.map {|item| compact(item, property: property)}.compact
 
         # If element has a single member and the active property has no
         # @container mapping to @list or @set, the compacted value is that
@@ -65,7 +65,7 @@ module JSON::LD
           end
 
           if expanded_property == '@reverse'
-            compacted_value = compact(expanded_value, '@reverse')
+            compacted_value = compact(expanded_value, property: '@reverse')
             #log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
             compacted_value.each do |prop, value|
               if context.reverse?(prop)
@@ -121,7 +121,7 @@ module JSON::LD
 
             container = context.container(item_active_property)
             value = list?(expanded_item) ? expanded_item['@list'] : expanded_item
-            compacted_item = compact(value, item_active_property)
+            compacted_item = compact(value, property: item_active_property)
             #log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
 
             if list?(expanded_item)

data/lib/json/ld/context.rb

@@ -186,6 +186,19 @@ module JSON::LD
     # @return [BlankNodeNamer]
     attr_accessor :namer
 
+    ##
+    # Create a new context by parsing a context.
+    #
+    # @see #initialize
+    # @see #parse
+    # @param [String, #read, Array, Hash, Context] local_context
+    # @raise [JsonLdError]
+    #   on a remote context load error, syntax error, or a reference to a term which is not defined.
+    # @return [Context]
+    def self.parse(local_context, **options)
+      self.new(options).parse(local_context)
+    end
+
     ##
     # Create new evaluation context
     # @param [Hash] options
@@ -204,7 +217,7 @@ module JSON::LD
     # @yield [ec]
     # @yieldparam [Context]
     # @return [Context]
-    def initialize(options = {})
+    def initialize(**options)
       if options[:base]
         @base = @doc_base = RDF::URI(options[:base]).dup
         @doc_base.canonicalize! if options[:canonicalize]
@@ -298,6 +311,7 @@ module JSON::LD
     # @param [String, #read, Array, Hash, Context] local_context
     # @raise [JsonLdError]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
+    # @return [Context]
     # @see http://json-ld.org/spec/latest/json-ld-api/index.html#context-processing-algorithm
     def parse(local_context, remote_contexts = [])
       result = self.dup
@@ -391,9 +405,9 @@ module JSON::LD
           # 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=,
+            '@base'     => :base=,
             '@language' => :default_language=,
-            '@vocab'    => :vocab=
+            '@vocab'    => :vocab=,
           }.each do |key, setter|
             v = context.fetch(key, false)
             unless v == false
@@ -797,16 +811,14 @@ module JSON::LD
     #
     # @param [String] value
     #   A keyword, term, prefix:suffix or possibly relative IRI
-    # @param  [Hash{Symbol => Object}] options
     # @param [Boolean] documentRelative (false)
     # @param [Boolean] vocab (false)
-    # @param [RDF::URI] base
     # @param [Hash] local_context
     #   Used during Context Processing.
     # @param [Hash] defined
     #   Used during Context Processing.
     # @param [Boolean] quiet (false)
-    # @param [Hash] options ({})
+    # @param  [Hash{Symbol => Object}] options
     # @return [RDF::URI, String]
     #   IRI or String, if it's a keyword
     # @raise [JSON::LD::JsonLdError::InvalidIRIMapping] if the value cannot be expanded
@@ -878,7 +890,7 @@ module JSON::LD
     # @param [RDF::URI] iri
     # @param [Object] value
     #   Value, used to select among various maps for the same IRI
-    # @param [Boolean] :vocab
+    # @param [Boolean] vocab
     #   specifies whether the passed iri should be compacted using the active context's vocabulary mapping
     # @param [Boolean] reverse
     #   specifies whether a reverse property is being compacted 
@@ -1193,7 +1205,7 @@ module JSON::LD
       defn << "vocab: #{self.vocab.to_s.inspect}" if self.vocab
       term_defs = term_definitions.map do |term, td|
         "      " + term.inspect + " => " + td.to_rb
-      end
+      end.sort
       defn << "term_definitions: {\n#{term_defs.join(",\n")    }\n    }" unless term_defs.empty?
       %(# -*- encoding: utf-8 -*-
       # frozen_string_literal: true

data/lib/json/ld/expand.rb

@@ -14,10 +14,9 @@ module JSON::LD
     # @param [Context] context
     # @param [Boolean] ordered (true)
     #   Ensure output objects have keys ordered properly
-    # @param [Boolean] framing (false)
-    # @param [Boolean] keep_free_floating_notes (false)
-    # @return [Array, Hash]
-    def expand(input, active_property, context, ordered: true, framing: false, keep_free_floating_nodes: false)
+    # @return [Array<Hash{String => Object}>]
+    def expand(input, active_property, context, ordered: true)
+      framing = @options[:processingMode].include?("expand-frame")
       #log_debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       result = case input
       when Array
@@ -73,18 +72,37 @@ module JSON::LD
             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
-              case value
+              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
 
-              # Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
-              context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
+              # 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}"}
@@ -101,28 +119,55 @@ module JSON::LD
                 # For framing
                 raise JsonLdError::InvalidTypeValue,
                       "@type value must be a an empty object for framing: #{value.inspect}" unless
-                      value.empty?
+                      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.
-              expand(value, '@graph', context, ordered: ordered)
+              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.
-              raise JsonLdError::InvalidValueObjectValue,
-                    "Value of #{expanded_property} must be a scalar or null: #{value.inspect}" if value.is_a?(Hash) || value.is_a?(Array)
-              if value.nil?
+              # 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
-              value
             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.
-              raise JsonLdError::InvalidLanguageTaggedString,
-                    "Value of #{expanded_property} must be a string: #{value.inspect}" unless value.is_a?(String)
-              value.downcase
+              # 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,
@@ -186,7 +231,8 @@ module JSON::LD
 
               # Continue with the next key from element
               next
-            when '@explicit', '@default', '@embed', '@explicit', '@omitDefault', '@preserve', '@requireAll'
+            when '@default', '@embed', '@explicit', '@omitDefault', '@preserve', '@requireAll'
+              next unless framing
               # Framing keywords
               [expand(value, expanded_property, context, ordered: ordered)].flatten
             else
@@ -291,21 +337,22 @@ module JSON::LD
             "value object has unknown keys: #{output_object.inspect}"
           end
 
-          output_object.delete('@language') if output_object['@language'].to_s.empty?
-          output_object.delete('@type') if output_object['@type'].to_s.empty?
+          output_object.delete('@language') if Array(output_object['@language']).join('').to_s.empty?
+          output_object.delete('@type') if Array(output_object['@type']).join('').to_s.empty?
 
           # If the value of result's @value key is null, then set result to null.
-          return nil if output_object['@value'].nil?
+          return nil if Array(output_object['@value']).empty?
 
-          if !output_object['@value'].is_a?(String) && output_object.has_key?('@language')
+          if !Array(output_object['@value']).all? {|v| v.is_a?(String) || v.is_a?(Hash) && v.empty?} && output_object.has_key?('@language')
             # Otherwise, if the value of result's @value member is not a string and result contains the key @language, an invalid language-tagged value error has been detected (only strings can be language-tagged) and processing is aborted.
             raise JsonLdError::InvalidLanguageTaggedValue,
-                  "when @language is used, @value must be a string: #{@value.inspect}"
-          elsif !output_object.fetch('@type', "").is_a?(String) ||
-                !context.expand_iri(output_object.fetch('@type', ""), vocab: true, log_depth: @options[:log_depth]).is_a?(RDF::URI)
+                  "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) ||
+                  t.is_a?(Hash) && t.empty?}
             # Otherwise, if the result has a @type member and its value is not an IRI, an invalid typed value error has been detected and processing is aborted.
             raise JsonLdError::InvalidTypedValue,
-                  "value of @type must be an IRI: #{output_object['@type'].inspect}"
+                  "value of @type must be an IRI: #{output_object.inspect}"
           end
         elsif !output_object.fetch('@type', []).is_a?(Array)
           # Otherwise, if result contains the key @type and its associated value is not an array, set it to an array containing only the associated value.
@@ -327,7 +374,7 @@ module JSON::LD
         # If active property is null or @graph, drop free-floating values as follows:
         if (active_property || '@graph') == '@graph' &&
           (output_object.keys.any? {|k| %w(@value @list).include?(k)} ||
-           (output_object.keys - %w(@id)).empty? && !keep_free_floating_nodes)
+           (output_object.keys - %w(@id)).empty? && !framing)
           #log_debug(" =>") { "empty top-level: " + output_object.inspect}
           return nil
         end