json-ld 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9fcb46a6c6bf33bfed92adcc8a751598cec5d6511e0450d38c9920bfdb696ce
-  data.tar.gz: 6fec905be8d5e0335149da757fef899d6e3fa948e852f74e9c88d0bff45801ae
+  metadata.gz: 686aaec1dba1b51a5f37e1d4ebd28395c189c0944022b1b9877c7c5a8500cef3
+  data.tar.gz: 5a9f07dd8fc17e3b4b3129b45cbd783e5390b7921da10c62d7d087621e1e123d
 SHA512:
-  metadata.gz: 1a7d07de17bc462f2f38fc24ae7c2a04a2c1ffd24d0a431626771259d59ffd6fe4b33b4ea8501add71d710e3c4501897454aada60ff6054fa9a12ef69cf488f3
-  data.tar.gz: 48da4933e6660ccd7cffe9cdcb08b576d883f1c744a889867b5e8619f9c3908fad00af02a739bc9af5c1abd7495d3cb9517d914ee12f7ac4f48acf94b5b9b637
+  metadata.gz: f3bb2f7b57db9b1689e43ceca7fbe497f0c67fffd5c12a8a7b451f07e0acf45be1f45f30d3acfd2e7e5ab1a52b9486954e8af1ebceb40478599b1fa8d9809035
+  data.tar.gz: 8acfd478567cec305f2a37e189a7ba11c2bb75463746bc1a114be79b71ea3e84b19632224515b0e2097c2a2a16293f098eb06556d74bb6a2a7e32516ad1476d3

data/VERSION

@@ -1 +1 @@
-3.1.0
+3.1.1

data/lib/json/ld.rb

@@ -115,7 +115,7 @@ module JSON
       class CyclicIRIMapping < JsonLdError; @code = "cyclic IRI mapping"; end
       class InvalidBaseIRI < JsonLdError; @code = "invalid base IRI"; end
       class InvalidContainerMapping < JsonLdError; @code = "invalid container mapping"; end
-      class InvalidContextMember < JsonLdError; @code = "invalid context member"; end
+      class InvalidContextEntry < JsonLdError; @code = "invalid context entry"; end
       class InvalidContextNullification < JsonLdError; @code = "invalid context nullification"; end
       class InvalidDefaultLanguage < JsonLdError; @code = "invalid default language"; end
       class InvalidIdValue < JsonLdError; @code = "invalid @id value"; end

data/lib/json/ld/api.rb

@@ -35,7 +35,7 @@ module JSON::LD
 
     # Options used for open_file
     OPEN_OPTS = {
-      headers: {"Accept" => "application/ld+json, text/html;q=0.8, application/json;q=0.5"}
+      headers: {"Accept" => "application/ld+json, text/html;q=0.8, application/xhtml+xml;q=0.8, application/json;q=0.5"}
     }
 
     # The following constants are used to reduce object allocations
@@ -229,7 +229,7 @@ module JSON::LD
         # xxx) Add the given context to the output
         ctx = self.context.serialize
         if result.is_a?(Array)
-          kwgraph = self.context.compact_iri('@graph', vocab: true, quiet: true)
+          kwgraph = self.context.compact_iri('@graph', vocab: true)
           result = result.empty? ? {} : {kwgraph => result}
         end
         result = ctx.merge(result) unless ctx.empty?
@@ -295,7 +295,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 = as_array(compact(flattened, ordered: @options[:ordered]))
-          kwgraph = self.context.compact_iri('@graph', quiet: true)
+          kwgraph = self.context.compact_iri('@graph')
           flattened = self.context.serialize.merge(kwgraph => compacted)
         end
       end
@@ -313,11 +313,11 @@ module JSON::LD
     # @param [String, #read, Hash, Array] frame
     #   The frame to use when re-arranging the data.
     # @option options (see #initialize)
-    # @option options ['@always', '@first', '@last', '@link', '@once', '@never'] :embed ('@last')
+    # @option options ['@always', '@link', '@once', '@never'] :embed ('@once')
     #   a flag specifying that objects should be directly embedded in the output, instead of being referred to by their IRI.
     # @option options [Boolean] :explicit (false)
     #   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)
+    # @option options [Boolean] :requireAll (false)
     #   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.
@@ -394,7 +394,7 @@ module JSON::LD
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
         create_node_map(value, framing_state[:graphMap], active_graph: '@default')
 
-        frame_keys = frame.keys.map {|k| context.expand_iri(k, vocab: true, quiet: true)}
+        frame_keys = frame.keys.map {|k| context.expand_iri(k, vocab: true)}
         if frame_keys.include?('@graph')
           # If frame contains @graph, it matches the default graph.
           framing_state[:graph] = '@default'
@@ -436,7 +436,7 @@ module JSON::LD
         result = if !compacted.is_a?(Array)
           context.serialize.merge(compacted)
         else
-          kwgraph = context.compact_iri('@graph', quiet: true)
+          kwgraph = context.compact_iri('@graph')
           context.serialize.merge({kwgraph => compacted})
         end
         log_debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
@@ -535,7 +535,7 @@ module JSON::LD
     # @param [Boolean] extractAllScripts
     #   If set to `true`, when extracting JSON-LD script elements from HTML, unless a specific fragment identifier is targeted, extracts all encountered JSON-LD script elements using an array form, if necessary.
     # @param [String] profile
-    #   When the resulting `contentType` is `text/html`, this option determines the profile to use for selecting a JSON-LD script elements.
+    #   When the resulting `contentType` is `text/html` or `application/xhtml+xml`, this option determines the profile to use for selecting a JSON-LD script elements.
     # @param [String] requestProfile
     #   One or more IRIs to use in the request as a profile parameter.
     # @param [Boolean] validate
@@ -612,7 +612,7 @@ module JSON::LD
         # Parse any HTML
         if remote_doc.document.is_a?(String)
           remote_doc.document = case remote_doc.contentType
-          when 'text/html'
+          when 'text/html', 'application/xhtml+xml'
             load_html(remote_doc.document,
                       url: remote_doc.documentUrl,
                       extractAllScripts: extractAllScripts,
@@ -628,7 +628,7 @@ module JSON::LD
 
         if remote_doc.contentType && validate
           raise IOError, "url: #{url}, contentType: #{remote_doc.contentType}" unless
-            remote_doc.contentType.match?(/application\/(.+\+)?json|text\/html/)
+            remote_doc.contentType.match?(/application\/(.+\+)?json|text\/html|application\/xhtml\+xml/)
         end
         block_given? ? yield(remote_doc) : remote_doc
       end
@@ -642,7 +642,7 @@ module JSON::LD
     # @param [Boolean] extractAllScripts
     #   If set to `true`, when extracting JSON-LD script elements from HTML, unless a specific fragment identifier is targeted, extracts all encountered JSON-LD script elements using an array form, if necessary.
     # @param [String] profile
-    #   When the resulting `contentType` is `text/html`, this option determines the profile to use for selecting a JSON-LD script elements.
+    #   When the resulting `contentType` is `text/html` or `application/xhtml+xml`, this option determines the profile to use for selecting a JSON-LD script elements.
     # @param [String] requestProfile
     #   One or more IRIs to use in the request as a profile parameter.
     # @param [Hash<Symbol => Object>] options
@@ -739,7 +739,7 @@ module JSON::LD
         elements = if profile
           es = input.xpath("//script[starts-with(@type, 'application/ld+json;profile=#{profile}')]")
           # If no profile script, just take a single script without profile
-          es = [input.at_xpath("//script[starts-with(@type, 'application/ld+json')]")] if es.empty?
+          es = [input.at_xpath("//script[starts-with(@type, 'application/ld+json')]")].compact if es.empty?
           es
         else
           input.xpath("//script[starts-with(@type, 'application/ld+json')]")

data/lib/json/ld/compact.rb

@@ -5,12 +5,7 @@ module JSON::LD
     include Utils
 
     # The following constant is used to reduce object allocations in #compact below
-    CONTAINER_MAPPING_ID = %w(@id).freeze
-    CONTAINER_MAPPING_INDEX = %w(@index).freeze
-    CONTAINER_MAPPING_LANGUAGE = %w(@language).freeze
     CONTAINER_MAPPING_LANGUAGE_INDEX_ID_TYPE = Set.new(%w(@language @index @id @type)).freeze
-    CONTAINER_MAPPING_LIST = %w(@list).freeze
-    CONTAINER_MAPPING_TYPE = %w(@type).freeze
     EXPANDED_PROPERTY_DIRECTION_INDEX_LANGUAGE_VALUE = %w(@direction @index @language @value).freeze
 
     ##
@@ -71,7 +66,7 @@ module JSON::LD
         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) == CONTAINER_MAPPING_LIST
+        if list?(element) && context.container(property).include?('@list')
           return compact(element['@list'], property: property, ordered: ordered)
         end
 
@@ -110,8 +105,7 @@ module JSON::LD
                        (context.as_array?(kw_alias) &&
                         !value?(element) &&
                         context.processingMode('json-ld-1.1'))
-            compacted_value = compacted_value.first unless as_array
-            result[kw_alias] = compacted_value
+            add_value(result, kw_alias, compacted_value, property_is_array: as_array)
             next
           end
 
@@ -128,7 +122,7 @@ module JSON::LD
             end
 
             unless compacted_value.empty?
-              al = context.compact_iri('@reverse', quiet: true)
+              al = context.compact_iri('@reverse')
               #log_debug("") {"remainder: #{al} => #{compacted_value.inspect}"}
               result[al] = compacted_value
             end
@@ -146,14 +140,14 @@ module JSON::LD
             next
           end
 
-          if expanded_property == '@index' && context.container(property) == CONTAINER_MAPPING_INDEX
+          if expanded_property == '@index' && context.container(property).include?('@index')
             #log_debug("@index") {"drop @index"}
             next
           end
 
           # Otherwise, if expanded property is @direction, @index, @value, or @language:
           if EXPANDED_PROPERTY_DIRECTION_INDEX_LANGUAGE_VALUE.include?(expanded_property)
-            al = context.compact_iri(expanded_property, vocab: true, quiet: true)
+            al = context.compact_iri(expanded_property, vocab: true)
             #log_debug(expanded_property) {"#{al} => #{expanded_value.inspect}"}
             result[al] = expanded_value
             next
@@ -209,11 +203,11 @@ module JSON::LD
             # handle @list
             if list?(expanded_item)
               compacted_item = as_array(compacted_item)
-              unless container == CONTAINER_MAPPING_LIST
-                al = context.compact_iri('@list', vocab: true, quiet: true)
+              unless container.include?('@list')
+                al = context.compact_iri('@list', vocab: true)
                 compacted_item = {al => compacted_item}
                 if expanded_item.has_key?('@index')
-                  key = context.compact_iri('@index', vocab: true, quiet: true)
+                  key = context.compact_iri('@index', vocab: true)
                   compacted_item[key] = expanded_item['@index']
                 end
               else
@@ -231,11 +225,11 @@ module JSON::LD
                 map_object = nest_result[item_active_property] ||= {}
                 # If there is no @id, create a blank node identifier to use as an index
                 map_key = if container.include?('@id') && expanded_item['@id']
-                  context.compact_iri(expanded_item['@id'], quiet: true)
+                  context.compact_iri(expanded_item['@id'])
                 elsif container.include?('@index') && expanded_item['@index']
-                  context.compact_iri(expanded_item['@index'], quiet: true)
+                  context.compact_iri(expanded_item['@index'])
                 else
-                  context.compact_iri('@none', vocab: true, quiet: true)
+                  context.compact_iri('@none', vocab: true)
                 end
                 add_value(map_object, map_key, compacted_item,
                   property_is_array: as_array)
@@ -243,7 +237,7 @@ module JSON::LD
                 # container includes @graph but not @id or @index and value is a simple graph object
                 if compacted_item.is_a?(Array) && compacted_item.length > 1
                   # Mutple objects in the same graph can't be represented directly, as they would be interpreted as two different graphs. Need to wrap in @included.
-                  included_key = context.compact_iri('@included', vocab: true).to_s
+                  included_key = context.compact_iri('@included', vocab: true)
                   compacted_item = {included_key => compacted_item}
                 end
                 # Drop through, where compacted_item will be added
@@ -251,35 +245,34 @@ module JSON::LD
                   property_is_array: as_array)
               else
                 # container does not include @graph or otherwise does not match one of the previous cases, redo compacted_item
-                al = context.compact_iri('@graph', vocab: true, quiet: true)
+                al = context.compact_iri('@graph', vocab: true)
                 compacted_item = {al => compacted_item}
                 if expanded_item['@id']
-                  al = context.compact_iri('@id', vocab: true, quiet: true)
-                  compacted_item[al] = context.compact_iri(expanded_item['@id'], vocab: false, quiet: true).to_s
+                  al = context.compact_iri('@id', vocab: true)
+                  compacted_item[al] = context.compact_iri(expanded_item['@id'], vocab: false)
                 end
                 if expanded_item.has_key?('@index')
-                  key = context.compact_iri('@index', vocab: true, quiet: true)
+                  key = context.compact_iri('@index', vocab: true)
                   compacted_item[key] = expanded_item['@index']
                 end
                 add_value(nest_result, item_active_property, compacted_item,
                   property_is_array: as_array)
               end
-            elsif container.any? { |key| CONTAINER_MAPPING_LANGUAGE_INDEX_ID_TYPE.include?(key) } && !container.include?('@graph')
+            elsif container.intersect?(CONTAINER_MAPPING_LANGUAGE_INDEX_ID_TYPE) && !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 CONTAINER_MAPPING_ID
+              container_key = context.compact_iri(c, vocab: true)
+              compacted_item = case
+              when container.include?('@id')
                 map_key = compacted_item[container_key]
                 compacted_item.delete(container_key)
                 compacted_item
-              when CONTAINER_MAPPING_INDEX
+              when container.include?('@index')
                 index_key = context.term_definitions[item_active_property].index || '@index'
                 if index_key == '@index'
                   map_key = expanded_item['@index']
-                  compacted_item.delete(container_key) if compacted_item.is_a?(Hash)
                 else
-                  container_key = context.compact_iri(index_key, vocab: true, quiet: true)
+                  container_key = context.compact_iri(index_key, vocab: true)
                   map_key, *others = Array(compacted_item[container_key])
                   if map_key.is_a?(String)
                     case others.length
@@ -288,15 +281,15 @@ module JSON::LD
                     else        compacted_item[container_key] = others
                     end
                   else
-                    map_key = context.compact_iri('@none', vocab: true, quiet: true)
+                    map_key = context.compact_iri('@none', vocab: true)
                   end
                 end
                 # Note, if compacted_item is a node reference and key is @id-valued, then this could be compacted further.
                 compacted_item
-              when CONTAINER_MAPPING_LANGUAGE
+              when container.include?('@language')
                 map_key = expanded_item['@language']
                 value?(expanded_item) ? expanded_item['@value'] : compacted_item
-              when CONTAINER_MAPPING_TYPE
+              when container.include?('@type')
                 map_key, *types = Array(compacted_item[container_key])
                 case types.length
                 when 0 then compacted_item.delete(container_key)
@@ -310,7 +303,7 @@ module JSON::LD
                 end
                 compacted_item
               end
-              map_key ||= context.compact_iri('@none', vocab: true, quiet: true)
+              map_key ||= context.compact_iri('@none', vocab: true)
               add_value(map_object, map_key, compacted_item,
                 property_is_array: as_array)
             else

data/lib/json/ld/context.rb

@@ -3,6 +3,12 @@
 require 'json'
 require 'bigdecimal'
 require 'set'
+begin
+  # Attempt to load this to avoid unnecessary context fetches
+  require 'json-ld-preloaded'
+rescue LoadError
+  # Silently allow this to fail
+end
 
 module JSON::LD
   class Context
@@ -94,7 +100,7 @@ module JSON::LD
       # @param [String] term
       # @param [String] id
       # @param [String] type_mapping Type mapping
-      # @param [Array<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>] container_mapping
+      # @param [Set<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>] container_mapping
       # @param [String] language_mapping
       #   Language mapping of term, `false` is used if there is an explicit language mapping for this term
       # @param ["ltr", "rtl"] direction_mapping
@@ -140,12 +146,19 @@ module JSON::LD
 
       # Set container mapping, from an array which may include @set
       def container_mapping=(mapping)
-        mapping = Array(mapping)
+        mapping = case mapping
+        when Set then mapping
+        when Array then Set.new(mapping)
+        when String then Set[mapping]
+        when nil then Set.new
+        else
+          raise "Shouldn't happen with #{mapping.inspect}"
+        end
         if @as_set = mapping.include?('@set')
           mapping = mapping.dup
           mapping.delete('@set')
         end
-        @container_mapping = mapping.sort
+        @container_mapping = mapping
         @index ||= '@index' if mapping.include?('@index')
       end
 
@@ -201,7 +214,8 @@ module JSON::LD
           v = instance_variable_get("@#{acc}".to_sym)
           v = v.to_s if v.is_a?(RDF::Term)
           if acc == 'container_mapping'
-            v.concat(%w(@set)) if as_set?
+            v = v.to_a
+            v << '@set' if as_set?
             v = v.first if v.length <= 1
           end
           defn << "#{acc}: #{v.inspect}" if v
@@ -492,7 +506,7 @@ module JSON::LD
     #
     # @param [Boolean] value
     def propagate=(value, **options)
-      raise JsonLdError::InvalidContextMember, "@propagate may only be set in 1.1 mode" if processingMode("json-ld-1.0")
+      raise JsonLdError::InvalidContextEntry, "@propagate may only be set in 1.1 mode" if processingMode("json-ld-1.0")
       raise JsonLdError::InvalidPropagateValue, "@propagate must be boolean valued: #{value.inspect}" unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
       value
     end
@@ -626,7 +640,7 @@ module JSON::LD
             next unless context.has_key?(key)
             if key == '@import'
               # Retrieve remote context and merge the remaining context object into the result.
-              raise JsonLdError::InvalidContextMember, "@import may only be used in 1.1 mode}" if result.processingMode("json-ld-1.0")
+              raise JsonLdError::InvalidContextEntry, "@import may only be used in 1.1 mode}" if result.processingMode("json-ld-1.0")
               raise JsonLdError::InvalidImportValue, "@import must be a string: #{context['@import'].inspect}" unless context['@import'].is_a?(String)
               source = RDF::URI(result.context_base || result.base).join(context['@import'])
               begin
@@ -640,7 +654,7 @@ module JSON::LD
                   raise JsonLdError::InvalidRemoteContext, "#{source}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.has_key?('@context')
                   import_context = remote_doc.document['@context']
                   raise JsonLdError::InvalidRemoteContext, "#{import_context.to_json} must be an object" unless import_context.is_a?(Hash)
-                  raise JsonLdError::InvalidContextMember, "#{import_context.to_json} must not include @import entry" if import_context.has_key?('@import')
+                  raise JsonLdError::InvalidContextEntry, "#{import_context.to_json} must not include @import entry" if import_context.has_key?('@import')
                   context.delete(key)
                   context = import_context.merge(context)
                 end
@@ -1162,7 +1176,7 @@ module JSON::LD
     def container(term)
       return [term] if term == '@list'
       term = find_definition(term)
-      term ? term.container_mapping : []
+      term ? term.container_mapping : Set.new
     end
 
     ##
@@ -1281,18 +1295,24 @@ module JSON::LD
     #   Used during Context Processing.
     # @param [Hash] defined
     #   Used during Context Processing.
-    # @param [Boolean] quiet (false)
+    # @param [Boolean] as_string (false) transform RDF::Resource values to string
     # @param  [Hash{Symbol => Object}] options
-    # @return [RDF::URI, String]
+    # @return [RDF::Resource, String]
     #   IRI or String, if it's a keyword
     # @raise [JSON::LD::JsonLdError::InvalidIRIMapping] if the value cannot be expanded
     # @see https://www.w3.org/TR/json-ld11-api/#iri-expansion
-    def expand_iri(value, documentRelative: false, vocab: false, local_context: nil, defined: nil, quiet: false, **options)
-      return value unless value.is_a?(String)
+    def expand_iri(value,
+      documentRelative: false,
+      vocab: false,
+      local_context: nil,
+      defined: nil,
+      as_string: false,
+      **options
+    )
+      return (value && as_string ? value.to_s : value) unless value.is_a?(String)
 
       return value if KEYWORDS.include?(value)
       return nil if value.match?(/^@[a-zA-Z]+$/)
-      #log_debug("expand_iri") {"value: #{value.inspect}"} unless quiet
 
       defined = defined || {} # if we initialized in the keyword arg we would allocate {} at each invokation, even in the 2 (common) early returns above.
 
@@ -1302,25 +1322,28 @@ module JSON::LD
       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
+        return (as_string ? v_td.id.to_s : 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 (v_td = term_definitions[value]) && (vocab || KEYWORDS.include?(v_td.id))
-        #log_debug("") {"match with #{v_td.id}"} unless quiet
-        return v_td.id
+        return (as_string ? v_td.id.to_s : v_td.id)
       end
 
       # If value contains a colon (:), it is either an absolute IRI or a compact IRI:
       if value[1..-1].to_s.include?(':')
         prefix, suffix = value.split(':', 2)
-        #log_debug("") {"prefix: #{prefix.inspect}, suffix: #{suffix.inspect}, vocab: #{self.vocab.inspect}"} unless quiet
 
         # If prefix is underscore (_) or suffix begins with double-forward-slash (//), return value as it is already an absolute IRI or a blank node identifier.
-        return RDF::Node.new(namer.get_sym(suffix)) if prefix == '_'
-        return RDF::URI(value) if suffix.start_with?('//')
+        if prefix == '_'
+          v = RDF::Node.new(namer.get_sym(suffix))
+          return (as_string ? v.to_s : v)
+        end
+        if suffix.start_with?('//')
+          v = RDF::URI(value)
+          return (as_string ? v.to_s : v)
+        end
 
         # If local context is not null, it contains a key that equals prefix, and the value associated with the key that equals prefix in defined is not true, invoke the Create Term Definition algorithm, passing active context, local context, prefix as term, and defined. This will ensure that a term definition is created for prefix in active context during Context Processing.
         if local_context && local_context.has_key?(prefix) && !defined[prefix]
@@ -1329,15 +1352,14 @@ module JSON::LD
 
         # If active context contains a term definition for prefix, return the result of concatenating the IRI mapping associated with prefix and suffix.
         if (td = term_definitions[prefix]) && !td.id.nil? && td.prefix?
-          return td.id + suffix
+          return (as_string ? td.id.to_s : td.id) + suffix
         elsif RDF::URI(value).absolute?
           # Otherwise, if the value has the form of an absolute IRI, return it
-          return RDF::URI(value)
+          return (as_string ? value.to_s : RDF::URI(value))
         else
           # Otherwise, it is a relative IRI
         end
       end
-      #log_debug("") {"=> #{result.inspect}"} unless quiet
 
       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.
@@ -1352,8 +1374,7 @@ module JSON::LD
       else
         RDF::URI(value)
       end
-      #log_debug("") {"=> #{result}"} unless quiet
-      result
+      result && as_string ? result.to_s : result
     end
 
     # The following constants are used to reduce object allocations in #compact_iri below
@@ -1378,18 +1399,15 @@ module JSON::LD
     #   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
-    # @param [Boolean] quiet (false)
     # @param  [Hash{Symbol => Object}] options ({})
     #
     # @return [String] compacted form of IRI
     # @see https://www.w3.org/TR/json-ld11-api/#iri-compaction
-    def compact_iri(iri, value: nil, vocab: nil, reverse: false, quiet: false, **options)
+    def compact_iri(iri, value: nil, vocab: nil, reverse: false, **options)
       return if iri.nil?
       iri = iri.to_s
-      #log_debug("compact_iri(#{iri.inspect}", options) {[value, vocab, reverse].inspect} unless quiet
 
       if vocab && inverse_context.has_key?(iri)
-        #log_debug("") {"vocab and key in inverse context"} unless quiet
         default_language = if self.default_direction
           "#{self.default_language}_#{self.default_direction}".downcase
         else
@@ -1406,7 +1424,6 @@ module JSON::LD
           tl, tl_value = "@type", "@reverse"
           containers << '@set'
         elsif list?(value)
-          #log_debug("") {"list(#{value.inspect})"} unless quiet
           # if value is a list object, then set type/language and type/language value to the most specific values that work for all items in the list as follows:
           containers << "@list" unless index?(value)
           list = value['@list']
@@ -1429,25 +1446,21 @@ module JSON::LD
             end
             common_language ||= item_language
             if item_language != common_language && value?(item)
-              #log_debug("") {"-- #{item_language} conflicts with #{common_language}, use @none"} unless quiet
               common_language = '@none'
             end
             common_type ||= item_type
             if item_type != common_type
               common_type = '@none'
-              #log_debug("") {"#{item_type} conflicts with #{common_type}, use @none"} unless quiet
             end
           end
 
           common_language ||= '@none'
           common_type ||= '@none'
-          #log_debug("") {"common type: #{common_type}, common language: #{common_language}"} unless quiet
           if common_type != '@none'
             tl, tl_value = '@type', common_type
           else
             tl_value = common_language
           end
-          #log_debug("") {"list: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless quiet
         elsif graph?(value)
           # Prefer @index and @id containers, then @graph, then @index
           containers.concat(CONTAINERS_GRAPH_INDEX_INDEX) if index?(value)
@@ -1482,7 +1495,6 @@ module JSON::LD
             tl, tl_value = '@type', '@id'
           end
           containers << '@set'
-          #log_debug("") {"value: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless quiet
         end
 
         containers << '@none'
@@ -1506,7 +1518,6 @@ module JSON::LD
           tl = '@any' if list?(value) && value['@list'].empty?
           preferred_values.concat([tl_value, '@none'].compact)
         end
-        #log_debug("") {"preferred_values: #{preferred_values.inspect}"} unless quiet
         preferred_values << '@any'
 
         # if containers included `@language` and preferred_values includes something of the form language-tag_direction, add just the _direction part, to select terms that have that direction.
@@ -1515,7 +1526,6 @@ module JSON::LD
         end
 
         if p_term = select_term(iri, containers, tl, preferred_values)
-          #log_debug("") {"=> term: #{p_term.inspect}"} unless quiet
           return p_term
         end
       end
@@ -1523,7 +1533,6 @@ module JSON::LD
       # At this point, there is no simple term that iri can be compacted to. If vocab is true and active context has a vocabulary mapping:
       if vocab && self.vocab && iri.start_with?(self.vocab) && iri.length > self.vocab.length
         suffix = iri[self.vocab.length..-1]
-        #log_debug("") {"=> vocab suffix: #{suffix.inspect}"} unless quiet
         return suffix unless term_definitions.has_key?(suffix)
       end
 
@@ -1566,10 +1575,8 @@ module JSON::LD
       if !vocab
         # transform iri to a relative IRI using the document's base IRI
         iri = remove_base(iri)
-        #log_debug("") {"=> relative iri: #{iri.inspect}"} unless quiet
         return iri
       else
-        #log_debug("") {"=> absolute iri: #{iri.inspect}"} unless quiet
         return iri
       end
     end
@@ -1830,9 +1837,9 @@ module JSON::LD
 
   private
 
-    CONTEXT_CONTAINER_ARRAY_TERMS = %w(@set @list @graph).freeze
-    CONTEXT_CONTAINER_ID_GRAPH = %w(@id @graph).freeze
-    CONTEXT_CONTAINER_INDEX_GRAPH = %w(@index @graph).freeze
+    CONTEXT_CONTAINER_ARRAY_TERMS = Set.new(%w(@set @list @graph)).freeze
+    CONTEXT_CONTAINER_ID_GRAPH = Set.new(%w(@id @graph)).freeze
+    CONTEXT_CONTAINER_INDEX_GRAPH = Set.new(%w(@index @graph)).freeze
     CONTEXT_BASE_FRAG_OR_QUERY = %w(? #).freeze
     CONTEXT_TYPE_ID_VOCAB = %w(@id @vocab).freeze
 
@@ -1906,7 +1913,7 @@ module JSON::LD
         end.each do |term|
           next unless td = term_definitions[term]
 
-          container = td.container_mapping.join('')
+          container = td.container_mapping.to_a.join('')
           if container.empty?
             container = td.as_set? ? %(@set) : %(@none)
           end
@@ -1943,7 +1950,7 @@ module JSON::LD
             lang_dir = td.direction_mapping ? "_#{td.direction_mapping}" : '@none'
             language_map[lang_dir] ||= term
           elsif default_direction
-            language_map[("#{td.language_mapping}_#{default_direction}").downcase] ||= term
+            language_map["_#{default_direction}"] ||= term
             language_map['@none'] ||= term
             type_map['@none'] ||= term
           else
@@ -2058,7 +2065,7 @@ module JSON::LD
               "'@container' on term #{term.inspect} must be a string: #{container.inspect}"
       end
 
-      val = Array(container).dup
+      val = Set.new(Array(container))
       val.delete('@set') if has_set = val.include?('@set')
 
       if val.include?('@list')
@@ -2088,7 +2095,7 @@ module JSON::LD
                processingMode('json-ld-1.0')
         raise JsonLdError::InvalidContainerMapping,
           "'@container' on term #{term.inspect} using @id cannot have any values other than @set and/or @graph, found  #{container.inspect}" unless
-          (val - CONTEXT_CONTAINER_ID_GRAPH).empty?
+          val.subset?(CONTEXT_CONTAINER_ID_GRAPH)
         # Okay
       elsif val.include?('@type') || val.include?('@graph')
         raise JsonLdError::InvalidContainerMapping,

data/lib/json/ld/expand.rb

@@ -9,13 +9,8 @@ module JSON::LD
     include Utils
 
     # The following constant is used to reduce object allocations
-    CONTAINER_INDEX_ID_TYPE = Set.new(%w(@index @id @type)).freeze
-    CONTAINER_GRAPH_INDEX = %w(@graph @index).freeze
-    CONTAINER_INDEX = %w(@index).freeze
-    CONTAINER_ID = %w(@id).freeze
-    CONTAINER_LIST = %w(@list).freeze
-    CONTAINER_TYPE = %w(@type).freeze
-    CONTAINER_GRAPH_ID = %w(@graph @id).freeze
+    CONTAINER_INDEX_ID_TYPE = Set['@index', '@id', '@type'].freeze
+    KEY_ID = %w(@id).freeze
     KEYS_VALUE_LANGUAGE_TYPE_INDEX_DIRECTION = %w(@value @language @type @index @direction).freeze
     KEYS_SET_LIST_INDEX = %w(@set @list @index).freeze
     KEYS_INCLUDED_TYPE = %w(@included @type).freeze
@@ -36,7 +31,7 @@ module JSON::LD
     def expand(input, active_property, context, ordered: false, framing: false, from_map: false)
       #log_debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       framing = false if active_property == '@default'
-      expanded_active_property = context.expand_iri(active_property, vocab: true).to_s if active_property
+      expanded_active_property = context.expand_iri(active_property, vocab: true, as_string: true) if active_property
 
       # Use a term-specific context, if defined, based on the non-type-scoped context.
       property_scoped_context = context.term_definitions[active_property].context if active_property && context.term_definitions[active_property]
@@ -44,7 +39,7 @@ module JSON::LD
       result = case input
       when Array
         # If element is an array,
-        is_list = context.container(active_property) == CONTAINER_LIST
+        is_list = context.container(active_property).include?('@list')
         value = input.each_with_object([]) do |v, memo|
           # Initialize expanded item to the result of using this algorithm recursively, passing active context, active property, and item as element.
           v = expand(v, active_property, context, ordered: ordered, framing: framing, from_map: from_map)
@@ -62,7 +57,7 @@ module JSON::LD
         value
       when Hash
         if context.previous_context
-          expanded_key_map = input.keys.inject({}) {|memo, key| memo.merge(key => context.expand_iri(key, vocab: true).to_s)}
+          expanded_key_map = input.keys.inject({}) {|memo, key| memo.merge(key => context.expand_iri(key, vocab: true, as_string: true))}
           # Revert any previously type-scoped term definitions, unless this is from a map, a value object or a subject reference
           revert_context = !from_map &&
             !expanded_key_map.values.include?('@value') &&
@@ -139,7 +134,7 @@ module JSON::LD
             raise JsonLdError::InvalidLanguageTaggedValue,
                   "when @language is used, @value must be a string: #{output_object.inspect}"
           elsif !Array(output_object['@type']).all? {|t|
-                  t.is_a?(String) && RDF::URI(t).absolute? && !t.start_with?('_:') ||
+                  t.is_a?(String) && RDF::URI(t).valid? && !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,
@@ -164,8 +159,8 @@ module JSON::LD
 
         # If active property is null or @graph, drop free-floating values as follows:
         if (expanded_active_property || '@graph') == '@graph' &&
-          (output_object.key?('@value') || output_object.key?('@list') ||
-           (output_object.keys - CONTAINER_ID).empty? && !framing)
+           (output_object.key?('@value') || output_object.key?('@list') ||
+           (output_object.keys - KEY_ID).empty? && !framing)
           #log_debug(" =>") { "empty top-level: " + output_object.inspect}
           return nil
         end
@@ -202,14 +197,14 @@ module JSON::LD
       nests = []
 
       input_type = Array(input[type_key]).last
-      input_type = context.expand_iri(input_type, vocab: true, quiet: true) if input_type
+      input_type = context.expand_iri(input_type, vocab: true, as_string: true) if input_type
 
       # Then, proceed and process each property and value in element as follows:
       keys = ordered ? input.keys.sort : input.keys
       keys.each do |key|
         # For each key and value in element, ordered lexicographically by key:
         value = input[key]
-        expanded_property = context.expand_iri(key, vocab: true, quiet: true)
+        expanded_property = context.expand_iri(key, vocab: 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?
@@ -241,16 +236,16 @@ module JSON::LD
             # 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
+              context.expand_iri(value, documentRelative: true, as_string: true)
             when Array
               # Framing allows an array of IRIs, and always puts values in an array
               raise JsonLdError::InvalidIdValue,
                     "value of @id must be a string unless framing: #{value.inspect}" unless framing
-              context.expand_iri(value, documentRelative: true, quiet: true).to_s
+              context.expand_iri(value, documentRelative: true, as_string: true)
               value.map do |v|
                 raise JsonLdError::InvalidTypeValue,
                       "@id value must be a string or array of strings for framing: #{v.inspect}" unless v.is_a?(String)
-                context.expand_iri(v, documentRelative: true, quiet: true,).to_s
+                context.expand_iri(v, documentRelative: true, as_string: true)
               end
             when Hash
               raise JsonLdError::InvalidIdValue,
@@ -287,21 +282,21 @@ module JSON::LD
               value.map do |v|
                 raise JsonLdError::InvalidTypeValue,
                       "@type value must be a string or array of strings: #{v.inspect}" unless v.is_a?(String)
-                type_scoped_context.expand_iri(v, vocab: true, documentRelative: true, quiet: true).to_s
+                type_scoped_context.expand_iri(v, vocab: true, documentRelative: true, as_string: true)
               end
             when String
-              type_scoped_context.expand_iri(value, vocab: true, documentRelative: true, quiet: true).to_s
+              type_scoped_context.expand_iri(value, vocab: true, documentRelative: true, as_string: true)
             when Hash
               if !framing
                 raise JsonLdError::InvalidTypeValue,
                       "@type value must be a string or array of strings: #{value.inspect}"
               elsif value.keys.length == 1 &&
-                 type_scoped_context.expand_iri(value.keys.first, vocab: true, quiet: true).to_s == '@default'
+                 type_scoped_context.expand_iri(value.keys.first, vocab: true) == '@default'
                 # Expand values of @default, which must be a string, or array of strings expanding to IRIs
                 [{'@default' => Array(value['@default']).map do |v|
                   raise JsonLdError::InvalidTypeValue,
                         "@type default value must be a string or array of strings: #{v.inspect}" unless v.is_a?(String)
-                  type_scoped_context.expand_iri(v, vocab: true, documentRelative: true, quiet: true).to_s
+                  type_scoped_context.expand_iri(v, vocab: true, documentRelative: true, as_string: true)
                 end}]
               elsif !value.empty?
                 raise JsonLdError::InvalidTypeValue,
@@ -481,7 +476,7 @@ module JSON::LD
         expanded_value = if context.coerce(key) == '@json'
           # In JSON-LD 1.1, values can be native JSON
           {"@value" => value, "@type" => "@json"}
-        elsif container.length == 1 && container.first == '@language' && value.is_a?(Hash)
+        elsif container.include?('@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.
@@ -490,7 +485,7 @@ 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 = context.expand_iri(k, vocab: true, quiet: true).to_s
+            expanded_k = context.expand_iri(k, vocab: true, as_string: true)
 
             if k !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/ && expanded_k != '@none'
               warn "@language must be valid BCP47: #{k.inspect}"
@@ -510,7 +505,7 @@ module JSON::LD
           end
 
           ary
-        elsif container.any? { |key| CONTAINER_INDEX_ID_TYPE.include?(key) } && value.is_a?(Hash)
+        elsif container.intersect?(CONTAINER_INDEX_ID_TYPE) && value.is_a?(Hash)
           # Otherwise, if key's container mapping in active context contains @index, @id, @type and value is a JSON object then value is expanded from an index map as follows:
           
           # Set ary to an empty array.
@@ -535,13 +530,13 @@ module JSON::LD
             map_context = container_context.parse(map_context, propagate: false) if map_context
             map_context ||= container_context
 
-            expanded_k = container_context.expand_iri(k, vocab: true, quiet: true).to_s
+            expanded_k = container_context.expand_iri(k, vocab: true, as_string: true)
 
             # Initialize index value to the result of using this algorithm recursively, passing active context, key as active property, and index value as element.
             index_value = expand([value[k]].flatten, key, map_context, ordered: ordered, framing: framing, from_map: true)
             index_value.each do |item|
-              case container
-              when CONTAINER_GRAPH_INDEX, CONTAINER_INDEX
+              case
+              when container.include?('@index')
                 # Indexed graph by graph name
                 if !graph?(item) && container.include?('@graph')
                   item = {'@graph' => as_array(item)}
@@ -553,18 +548,18 @@ module JSON::LD
                 else
                   # Expand key based on term
                   expanded_k = k == '@none' ? '@none' : container_context.expand_value(index_key, k)
-                  index_property = container_context.expand_iri(index_key, vocab: true, quiet: true).to_s
+                  index_property = container_context.expand_iri(index_key, vocab: true, as_string: true)
                   item[index_property] = [expanded_k].concat(Array(item[index_property])) unless expanded_k == '@none'
                 end
-              when CONTAINER_GRAPH_ID, CONTAINER_ID
+              when container.include?('@id')
                 # Indexed graph by graph name
                 if !graph?(item) && container.include?('@graph')
                   item = {'@graph' => as_array(item)}
                 end
                 # Expand k document relative
-                expanded_k = container_context.expand_iri(k, documentRelative: true, quiet: true).to_s unless expanded_k == '@none'
+                expanded_k = container_context.expand_iri(k, documentRelative: true, as_string: true) unless expanded_k == '@none'
                 item['@id'] ||= expanded_k unless expanded_k == '@none'
-              when CONTAINER_TYPE
+              when container.include?('@type')
                 item['@type'] = [expanded_k].concat(Array(item['@type'])) unless expanded_k == '@none'
               end
 

data/lib/json/ld/frame.rb

@@ -119,7 +119,7 @@ module JSON::LD
           end
         end
 
-        # If frame has `@included`, recurse over it's sub-frame
+        # If frame has `@included`, recurse over its sub-frame
         if frame['@included']
           frame(state.merge(embedded: false), subjects, frame['@included'], parent: output, property: '@included', **options)
         end

data/lib/json/ld/from_rdf.rb

@@ -42,7 +42,7 @@ module JSON::LD
 
         default_graph[name] ||= {'@id' => name} unless name == '@default'
 
-        subject = ec.expand_iri(statement.subject).to_s
+        subject = ec.expand_iri(statement.subject, as_string: true)
         node = node_map[subject] ||= {'@id' => subject}
 
         # If predicate is rdf:datatype, note subject in compound literal subjects map

data/lib/json/ld/to_rdf.rb

@@ -50,11 +50,11 @@ module JSON::LD
             # Either serialize using a datatype, or a compound-literal
             case @options[:rdfDirection]
             when 'i18n-datatype'
-              datatype = RDF::URI("https://www.w3.org/ns/i18n##{item.fetch('@language', '')}_#{item['@direction']}")
+              datatype = RDF::URI("https://www.w3.org/ns/i18n##{item.fetch('@language', '').downcase}_#{item['@direction']}")
             when 'compound-literal'
               cl = RDF::Node.new
               yield RDF::Statement(cl, RDF.value, item['@value'].to_s)
-              yield RDF::Statement(cl, RDF.to_uri + 'language', item['@language']) if item['@language']
+              yield RDF::Statement(cl, RDF.to_uri + 'language', item['@language'].downcase) if item['@language']
               yield RDF::Statement(cl, RDF.to_uri + 'direction', item['@direction'])
               return cl
             end
@@ -76,7 +76,13 @@ module JSON::LD
         return parse_list(item['@list'], graph_name: graph_name, &block)
       end
 
-      subject = item['@id'] ? as_resource(item['@id']) : node
+      # Skip if '@id' is nil
+      subject = if item.has_key?('@id')
+        item['@id'].nil? ? nil : as_resource(item['@id'])
+      else
+        node
+      end
+
       #log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
       item.each do |property, values|
         case property

data/lib/json/ld/writer.rb

@@ -143,8 +143,8 @@ module JSON::LD
           datatype: TrueClass,
           default: true,
           control: :checkbox,
-          on: ["--[no-]requireAll"],
-          description: "Require all properties to match (true). Default is `true` use --no-compact-to-relative to disable.") {|arg| arg},
+          on: ["--[no-]require-all"],
+          description: "Require all properties to match (true). Default is `true` use --no-require-all to disable.") {|arg| arg},
         RDF::CLI::Option.new(
           symbol: :stream,
           datatype: TrueClass,

data/spec/context_spec.rb

@@ -348,7 +348,7 @@ describe JSON::LD::Context do
         expect(subject.parse({
           "foo" => {"@id" => "http://example.com/", "@container" => "@list"}
         }).containers).to produce({
-          "foo" => %w(@list)
+          "foo" => Set["@list"]
         }, logger)
       end
 
@@ -356,7 +356,7 @@ describe JSON::LD::Context do
         expect(subject.parse({
           "foo" => {"@id" => "http://example.com/", "@container" => "@type"}
         }).containers).to produce({
-          "foo" => %w(@type)
+          "foo" => Set["@type"]
         }, logger)
       end
 
@@ -364,7 +364,7 @@ describe JSON::LD::Context do
         expect(subject.parse({
           "foo" => {"@id" => "http://example.com/", "@container" => "@id"}
         }).containers).to produce({
-          "foo" => %w(@id)
+          "foo" => Set["@id"]
         }, logger)
       end
 
@@ -553,12 +553,12 @@ describe JSON::LD::Context do
           end
         end
 
-        it "generates InvalidContextMember if using @propagate" do
-          expect {context.parse({'@propagate' => true})}.to raise_error(JSON::LD::JsonLdError::InvalidContextMember)
+        it "generates InvalidContextEntry if using @propagate" do
+          expect {context.parse({'@propagate' => true})}.to raise_error(JSON::LD::JsonLdError::InvalidContextEntry)
         end
 
-        it "generates InvalidContextMember if using @import" do
-          expect {context.parse({'@import' => "location"})}.to raise_error(JSON::LD::JsonLdError::InvalidContextMember)
+        it "generates InvalidContextEntry if using @import" do
+          expect {context.parse({'@import' => "location"})}.to raise_error(JSON::LD::JsonLdError::InvalidContextEntry)
         end
 
         (JSON::LD::KEYWORDS - %w(@base @language @version @protected @propagate @vocab)).each do |kw|
@@ -1796,23 +1796,23 @@ describe JSON::LD::Context do
 
     it "uses TermDefinition" do
       {
-        "ex"          => [],
-        "graph"       => %w(@graph),
-        "graphSet"    => %w(@graph),
-        "graphId"     => %w(@graph @id),
-        "graphIdSet"  => %w(@graph @id),
-        "graphNdx"    => %w(@graph @index),
-        "graphNdxSet" => %w(@graph @index),
-        "id"          => %w(@id),
-        "idSet"       => %w(@id),
-        "language"    => %w(@language),
-        "langSet"     => %w(@language),
-        "list"        => %w(@list),
-        "ndx"         => %w(@index),
-        "ndxSet"      => %w(@index),
-        "set"         => [],
-        "type"        => %w(@type),
-        "typeSet"     => %w(@type),
+        "ex"          => Set.new,
+        "graph"       => Set["@graph"],
+        "graphSet"    => Set["@graph"],
+        "graphId"     => Set["@graph", "@id"],
+        "graphIdSet"  => Set["@graph", "@id"],
+        "graphNdx"    => Set["@graph", "@index"],
+        "graphNdxSet" => Set["@graph", "@index"],
+        "id"          => Set['@id'],
+        "idSet"       => Set['@id'],
+        "language"    => Set['@language'],
+        "langSet"     => Set['@language'],
+        "list"        => Set['@list'],
+        "ndx"         => Set['@index'],
+        "ndxSet"      => Set['@index'],
+        "set"         => Set.new,
+        "type"        => Set['@type'],
+        "typeSet"     => Set['@type'],
       }.each do |defn, container|
         expect(subject.container(subject.term_definitions[defn])).to eq container
       end
@@ -1844,23 +1844,23 @@ describe JSON::LD::Context do
 
     it "uses array" do
       {
-        "ex"          => [],
-        "graph"       => %w(@graph),
-        "graphSet"    => %w(@graph),
-        "graphId"     => %w(@graph @id),
-        "graphIdSet"  => %w(@graph @id),
-        "graphNdx"    => %w(@graph @index),
-        "graphNdxSet" => %w(@graph @index),
-        "id"          => %w(@id),
-        "idSet"       => %w(@id),
-        "language"    => %w(@language),
-        "langSet"     => %w(@language),
-        "list"        => %w(@list),
-        "ndx"         => %w(@index),
-        "ndxSet"      => %w(@index),
-        "set"         => [],
-        "type"        => %w(@type),
-        "typeSet"     => %w(@type),
+        "ex"          => Set.new,
+        "graph"       => Set["@graph"],
+        "graphSet"    => Set["@graph"],
+        "graphId"     => Set["@graph", "@id"],
+        "graphIdSet"  => Set["@graph", "@id"],
+        "graphNdx"    => Set["@graph", "@index"],
+        "graphNdxSet" => Set["@graph", "@index"],
+        "id"          => Set['@id'],
+        "idSet"       => Set['@id'],
+        "language"    => Set['@language'],
+        "langSet"     => Set['@language'],
+        "list"        => Set['@list'],
+        "ndx"         => Set['@index'],
+        "ndxSet"      => Set['@index'],
+        "set"         => Set.new,
+        "type"        => Set['@type'],
+        "typeSet"     => Set['@type'],
       }.each do |defn, container|
         expect(subject.container(defn)).to eq container
       end
@@ -2053,13 +2053,13 @@ describe JSON::LD::Context do
 
     context "with container_mapping @id @set" do
       subject {described_class.new("term", container_mapping: %w(@id @set))}
-      its(:container_mapping) {is_expected.to eq %w(@id)}
+      its(:container_mapping) {is_expected.to eq Set['@id']}
       its(:to_rb) {is_expected.to eq %(TermDefinition.new("term", container_mapping: ["@id", "@set"]))}
     end
 
     context "with container_mapping @list" do
       subject {described_class.new("term", container_mapping: "@list")}
-      its(:container_mapping) {is_expected.to eq %w(@list)}
+      its(:container_mapping) {is_expected.to eq Set['@list']}
       its(:to_rb) {is_expected.to eq %(TermDefinition.new("term", container_mapping: "@list"))}
     end
 

data/spec/suite_expand_spec.rb

@@ -7,6 +7,8 @@ describe JSON::LD do
     m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}expand-manifest.jsonld")
     describe m.name do
       m.entries.each do |t|
+        # MultiJson use OJ, by default, which doesn't handle native numbers the same as the JSON gem.
+        t.options[:adapter] = :json_gem if %w(#tjs12).include?(t.property('@id'))
         specify "#{t.property('@id')}: #{t.name} unordered#{' (negative test)' unless t.positiveTest?}" do
           t.options[:ordered] = false
           if %w(#t0068).include?(t.property('@id'))

data/spec/suite_helper.rb

@@ -132,6 +132,10 @@ module Fixtures
           {'specVersion' => "json-ld-1.1"}.merge(property('option') || {}).each do |k, v|
             opts[k.to_sym] = v
           end
+          if opts[:expandContext] && !RDF::URI(opts[:expandContext]).absolute?
+            # Resolve relative to manifest location
+            opts[:expandContext] = manifest_url.join(opts[:expandContext]).to_s
+          end
           opts
         end
       end
@@ -144,6 +148,7 @@ module Fixtures
           file = self.send("#{m}_loc".to_sym)
 
           dl_opts = {safe: true}
+          dl_opts[:contentType] = options[:contentType] if m == 'input' && options[:contentType]
           RDF::Util::File.open_file(file, **dl_opts) do |remote_doc|
             res = remote_doc.read
           end

data/spec/to_rdf_spec.rb

@@ -1133,7 +1133,7 @@ describe JSON::LD::API do
           ],
           "en-US rtl": [
             %q({"http://example.org/label": {"@value": "en-US", "@language": "en-US", "@direction": "rtl"}}),
-            %q(_:a <http://example.org/label> "en-US"^^<https://www.w3.org/ns/i18n#en-US_rtl> .)
+            %q(_:a <http://example.org/label> "en-US"^^<https://www.w3.org/ns/i18n#en-us_rtl> .)
           ]
         }.each do |title, (js, ttl)|
           it title do
@@ -1161,7 +1161,7 @@ describe JSON::LD::API do
               @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
               _:a <http://example.org/label> [
                 rdf:value "en-US";
-                rdf:language "en-US";
+                rdf:language "en-us";
                 rdf:direction "rtl"
               ] .
             )
@@ -1218,7 +1218,7 @@ describe JSON::LD::API do
             "@id": "http://example.com/foo",
             "http://example.com/bar": {"@value": "bar", "@type": "http://example.com/baz z"}
           }),
-          output: %()
+          exception: JSON::LD::JsonLdError::InvalidTypedValue
         },
         "Injected IRIs check" => {
           input: %({

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-10 00:00:00.000000000 Z
+date: 2020-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: htmlentities
   requirement: !ruby/object:Gem::Requirement
@@ -424,7 +424,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: JSON-LD reader/writer for Ruby.