json-ld 3.2.3 → 3.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff11a49b52d7ca0faf6deaac7324f08530747b53ec857ebe007c027a1bf412b4
-  data.tar.gz: b0a808fc12be08ecaa47f399c0f20ff26120cc36820bf45d6c434ad1f31f53e3
+  metadata.gz: 7df92f96bef30d3af100b145f427533e3fa5bc2a91369e1edc86fd41dc2946bb
+  data.tar.gz: fcd7f3972ea390ace60be529f3106bd04823c8cddbb5efd050d0c9d134586028
 SHA512:
-  metadata.gz: c3e17fbb3280f393ece72136d09182d1032982ca116d49577f03dc72ca35ebc8193495054a1944e525acdad8ae67ce6cb341f6859c5e97a7d2497ca047d7ee40
-  data.tar.gz: eef60e136ca7d86ac66cd0b74d5b01862b4f5c7039352c7d6e678b73ab783bf7bbf2f397f7fd928421bc52e332389cab1432e69175d6fa0d260dfcf7a315a66a
+  metadata.gz: 3c1df99a21da6ae271caeedc44e0f66fffe77dbae771297153b45286d70a96044dcc97ea62a3aaffe74ac11a847ae52bf641410ba74e43cfed51c5f773c69c9a
+  data.tar.gz: ed0e35ecdaf9118b0ee81a34bb72f92e9344678a8c3e4311f4bed4a35d58bb217b2f4810e1f8cc5c59c97312399e716a237b5c1e841fd538c730d4e8e9e151c7

data/VERSION

@@ -1 +1 @@
-3.2.3
+3.2.4

data/lib/json/ld/api.rb

@@ -66,6 +66,7 @@ module JSON::LD
     # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   An external context to use additionally to the context embedded in input when expanding the input.
     # @param  [Hash{Symbol => Object}] options
+    # @option options [Symbol] :adapter used with MultiJson
     # @option options [RDF::URI, String, #to_s] :base
     #   The Base IRI to use when expanding the document. This overrides the value of `input` if it is a _IRI_. If not specified and `input` is not an _IRI_, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from `input`, options[:base] will be modified with this value.
     # @option options [Boolean] :compactArrays (true)
@@ -74,10 +75,10 @@ module JSON::LD
     #   Creates document relative IRIs when compacting, if `true`, otherwise leaves expanded.
     # @option options [Proc] :documentLoader
     #   The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See {documentLoader} for the method signature.
-    # @option options [Boolean] :lowercaseLanguage
-    #   By default, language tags are left as is. To normalize to lowercase, set this option to `true`.
     # @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 [Boolean] :extendedRepresentation (false)
+    #   Use the extended internal representation.
     # @option options [Boolean] :extractAllScripts
     #   If set, when given an HTML input without a fragment identifier, extracts all `script` elements with type `application/ld+json` into an array during expansion.
     # @option options [Boolean, String, RDF::URI] :flatten
@@ -86,19 +87,19 @@ module JSON::LD
     #   When set, this has the effect of inserting a context definition with `@language` set to the associated value, creating a default language for interpreting string values.
     # @option options [Symbol] :library
     #   One of :nokogiri or :rexml. If nil/unspecified uses :nokogiri if available, :rexml otherwise.
+    # @option options [Boolean] :lowercaseLanguage
+    #   By default, language tags are left as is. To normalize to lowercase, set this option to `true`.
+    # @option options [Boolean] :ordered (true)
+    #   Order traversal of dictionary members by key when performing algorithms.
     # @option options [String] :processingMode
     #   Processing mode, json-ld-1.0 or json-ld-1.1.
-    #   If `processingMode` is not specified, a mode of `json-ld-1.0` or `json-ld-1.1` is set, the context used for `expansion` or `compaction`.
-    # @option options [Boolean] rdfstar      (false)
+    # @option options [Boolean] :rdfstar      (false)
     #   support parsing JSON-LD-star statement resources.
     # @option options [Boolean] :rename_bnodes (true)
     #   Rename bnodes as part of expansion, or keep them the same.
     # @option options [Boolean]  :unique_bnodes   (false)
     #   Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
-    # @option options [Symbol] :adapter used with MultiJson
     # @option options [Boolean] :validate Validate input, if a string or readable object.
-    # @option options [Boolean] :ordered (true)
-    #   Order traversal of dictionary members by key when performing algorithms.
     # @yield [api]
     # @yieldparam [API]
     # @raise [JsonLdError]
@@ -235,7 +236,7 @@ module JSON::LD
       end
 
       API.new(expanded_input, context, no_default_base: true, **options) do
-        log_debug(".compact") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
+        # log_debug(".compact") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = compact(value)
 
         # xxx) Add the given context to the output
@@ -289,7 +290,7 @@ module JSON::LD
 
       # Initialize input using
       API.new(expanded_input, context, no_default_base: true, **options) do
-        log_debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
+        # log_debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Rename blank nodes recusively. Note that this does not create new blank node identifiers where none exist, which is performed in the node map generation algorithm.
         @value = rename_bnodes(@value) if @options[:rename_bnodes]
@@ -410,8 +411,8 @@ module JSON::LD
 
       # Initialize input using frame as context
       API.new(expanded_input, frame['@context'], no_default_base: true, **options) do
-        log_debug(".frame") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
-        log_debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
+        # log_debug(".frame") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
+        # log_debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         if %w(@first @last).include?(options[:embed]) && context.processingMode('json-ld-1.1')
           raise JSON::LD::JsonLdError::InvalidEmbedValue, "#{options[:embed]} is not a valid value of @embed in 1.1 mode" if @options[:validate]
@@ -458,7 +459,7 @@ module JSON::LD
 
         # Replace values with `@preserve` with the content of its entry.
         result = cleanup_preserve(result)
-        log_debug(".frame") {"expanded result: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
+        # log_debug(".frame") {"expanded result: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Compact result
         compacted = compact(result)
@@ -477,7 +478,7 @@ module JSON::LD
         # Only add context if one was provided
         result = context.serialize(provided_context: frame).merge(result) if frame['@context']
         
-        log_debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
+        # log_debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
         result
       end
 
@@ -518,7 +519,7 @@ module JSON::LD
       API.new(flattened_input, nil, **options) do
         # 1) Perform the Expansion Algorithm on the JSON-LD input.
         #    This removes any existing context to allow the given context to be cleanly applied.
-        log_debug(".toRdf") {"flattened input: #{flattened_input.to_json(JSON_STATE) rescue 'malformed json'}"}
+        # log_debug(".toRdf") {"flattened input: #{flattened_input.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Recurse through input
         flattened_input.each do |node|
@@ -527,7 +528,7 @@ module JSON::LD
 
             # Drop invalid statements (other than IRIs)
             unless statement.valid_extended?
-              log_debug(".toRdf") {"drop invalid statement: #{statement.to_nquads}"}
+              # log_debug(".toRdf") {"drop invalid statement: #{statement.to_nquads}"}
               next
             end
 
@@ -562,6 +563,7 @@ module JSON::LD
 
       API.new(nil, nil, **options) do
         result = from_statements(input,
+          extendedRepresentation: options[:extendedRepresentation],
           useRdfType: useRdfType,
           useNativeTypes: useNativeTypes)
       end
@@ -574,6 +576,9 @@ module JSON::LD
     # Uses built-in or provided documentLoader to retrieve a parsed document.
     #
     # @param [RDF::URI, String] url
+    # @param [Regexp] allowed_content_types
+    #   A regular expression matching other content types allowed
+    #   beyond types for JSON and HTML.
     # @param [String, RDF::URI] base
     #   Location to use as documentUrl instead of `url`.
     # @option options [Proc] :documentLoader
@@ -594,6 +599,7 @@ module JSON::LD
     #   If a block is given, the result of evaluating the block is returned, otherwise, the retrieved remote document and context information unless block given
     # @raise [JsonLdError]
     def self.loadRemoteDocument(url,
+                                allowed_content_types: nil,
                                 base: nil,
                                 documentLoader: nil,
                                 extractAllScripts: false,
@@ -674,7 +680,8 @@ 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|application\/xhtml\+xml/)
+            remote_doc.contentType.match?(/application\/(.+\+)?json|text\/html|application\/xhtml\+xml/) ||
+            (allowed_content_types && remote_doc.contentType.match?(allowed_content_types))
         end
         block_given? ? yield(remote_doc) : remote_doc
       end

data/lib/json/ld/compact.rb

@@ -21,14 +21,14 @@ module JSON::LD
                 base: nil,
                 property: nil,
                 log_depth: nil)
-      log_debug("compact", depth: log_depth.to_i) {"element: #{element.inspect}, ec: #{context.inspect}"}
+      # log_debug("compact", depth: log_depth.to_i) {"element: #{element.inspect}, ec: #{context.inspect}"}
 
       # If the term definition for active property itself contains a context, use that for compacting values.
       input_context = self.context
 
       case element
       when Array
-        #log_debug("") {"Array #{element.inspect}"}
+        # log_debug("") {"Array #{element.inspect}"}
         result = element.map do |item|
           compact(item, base: base, property: property, log_depth: log_depth.to_i + 1)
         end.compact
@@ -38,10 +38,10 @@ module JSON::LD
         # member; otherwise the compacted value is element
         if result.length == 1 &&
            !context.as_array?(property) && @options[:compactArrays]
-          log_debug("=> extract single element", depth: log_depth.to_i) {result.first.inspect}
+          # log_debug("=> extract single element", depth: log_depth.to_i) {result.first.inspect}
           result.first
         else
-          log_debug("=> array result", depth: log_depth.to_i) {result.inspect}
+          # log_debug("=> array result", depth: log_depth.to_i) {result.inspect}
           result
         end
       when Hash
@@ -52,7 +52,7 @@ module JSON::LD
 
         # Revert any previously type-scoped (non-preserved) context
         if context.previous_context && !element.key?('@value') && element.keys != %w(@id)
-          log_debug("revert ec", depth: log_depth.to_i) {"previous context: #{context.previous_context.inspect}"}
+          # log_debug("revert ec", depth: log_depth.to_i) {"previous context: #{context.previous_context.inspect}"}
           self.context = context.previous_context
         end
 
@@ -61,13 +61,13 @@ module JSON::LD
         if td && !td.context.nil?
           self.context = context.parse(td.context,
             override_protected: true)
-          log_debug("prop-scoped", depth: log_depth.to_i) {"context: #{self.context.inspect}"}
+          # log_debug("prop-scoped", depth: log_depth.to_i) {"context: #{self.context.inspect}"}
         end
 
         if (element.key?('@id') || element.key?('@value')) && !element.key?('@annotation')
           result = context.compact_value(property, element, base: @options[:base])
           if !result.is_a?(Hash) || context.coerce(property) == '@json'
-            log_debug("", depth: log_depth.to_i) {"=> scalar result: #{result.inspect}"}
+            # log_debug("", depth: log_depth.to_i) {"=> scalar result: #{result.inspect}"}
             return result
           end
         end
@@ -90,12 +90,12 @@ module JSON::LD
           each do |term|
           term_context = input_context.term_definitions[term].context if input_context.term_definitions[term]
           self.context = context.parse(term_context, propagate: false) unless term_context.nil?
-          log_debug("type-scoped", depth: log_depth.to_i) {"context: #{self.context.inspect}"}
+          # log_debug("type-scoped", depth: log_depth.to_i) {"context: #{self.context.inspect}"}
         end
 
         element.keys.opt_sort(ordered: @options[:ordered]).each do |expanded_property|
           expanded_value = element[expanded_property]
-          log_debug("", depth: log_depth.to_i) {"#{expanded_property}: #{expanded_value.inspect}"}
+          # log_debug("", depth: log_depth.to_i) {"#{expanded_property}: #{expanded_value.inspect}"}
 
           if expanded_property == '@id'
             compacted_value = as_array(expanded_value).map do |expanded_id|
@@ -134,7 +134,7 @@ module JSON::LD
             compacted_value = compact(expanded_value, base: base,
                                       property: '@reverse',
                                       log_depth: log_depth.to_i + 1)
-            log_debug("@reverse", depth: log_depth.to_i) {"compacted_value: #{compacted_value.inspect}"}
+            # log_debug("@reverse", depth: log_depth.to_i) {"compacted_value: #{compacted_value.inspect}"}
             # handle double-reversed properties
             compacted_value.each do |prop, value|
               if context.reverse?(prop)
@@ -146,7 +146,7 @@ module JSON::LD
 
             unless compacted_value.empty?
               al = context.compact_iri('@reverse', vocab: true)
-              log_debug("", depth: log_depth.to_i) {"remainder: #{al} => #{compacted_value.inspect}"}
+              # log_debug("", depth: log_depth.to_i) {"remainder: #{al} => #{compacted_value.inspect}"}
               result[al] = compacted_value
             end
             next
@@ -157,7 +157,7 @@ module JSON::LD
             compacted_value = compact(expanded_value, base: base,
                                       property: property,
                                       log_depth: log_depth.to_i + 1)
-            log_debug("@preserve", depth: log_depth.to_i) {"compacted_value: #{compacted_value.inspect}"}
+            # log_debug("@preserve", depth: log_depth.to_i) {"compacted_value: #{compacted_value.inspect}"}
 
             unless compacted_value.is_a?(Array) && compacted_value.empty?
               result['@preserve'] = compacted_value
@@ -166,14 +166,14 @@ module JSON::LD
           end
 
           if expanded_property == '@index' && context.container(property).include?('@index')
-            log_debug("@index", depth: log_depth.to_i) {"drop @index"}
+            # log_debug("@index", depth: log_depth.to_i) {"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)
-            log_debug(expanded_property, depth: log_depth.to_i) {"#{al} => #{expanded_value.inspect}"}
+            # log_debug(expanded_property, depth: log_depth.to_i) {"#{al} => #{expanded_value.inspect}"}
             result[al] = expanded_value
             next
           end
@@ -223,7 +223,7 @@ module JSON::LD
             compacted_item = compact(value, base: base,
                                      property: item_active_property,
                                      log_depth: log_depth.to_i + 1)
-            log_debug("", depth: log_depth.to_i) {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
+            # log_debug("", depth: log_depth.to_i) {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
 
             # handle @list
             if list?(expanded_item)
@@ -345,7 +345,7 @@ module JSON::LD
         result
       else
         # For other types, the compacted value is the element value
-        log_debug("compact", depth: log_depth.to_i) {element.class.to_s}
+        # log_debug("compact", depth: log_depth.to_i) {element.class.to_s}
         element
       end
 

data/lib/json/ld/context.rb

@@ -212,7 +212,7 @@ module JSON::LD
       self.default_language = options[:language] if options[:language] =~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
       @term_definitions = options[:term_definitions] if options[:term_definitions]
 
-      #log_debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
+      # log_debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
 
       yield(self) if block_given?
     end
@@ -267,13 +267,13 @@ module JSON::LD
                   "Attempt to clear a context with protected terms"
           end
         when Context
-           log_debug("parse") {"context: #{context.inspect}"}
+           # log_debug("parse") {"context: #{context.inspect}"}
            result = result.merge(context)
         when IO, StringIO
-          log_debug("parse") {"io: #{context}"}
+          # log_debug("parse") {"io: #{context}"}
           # Load context document, if it is an open file
           begin
-            ctx = JSON.load(context)
+            ctx = load_context(context, **@options)
             raise JSON::LD::JsonLdError::InvalidRemoteContext, "Context missing @context key" if @options[:validate] && ctx['@context'].nil?
             result = result.parse(ctx["@context"] ? ctx["@context"] : {})
           rescue JSON::ParserError => e
@@ -282,7 +282,7 @@ module JSON::LD
             self
           end
         when String, RDF::URI
-          log_debug("parse") {"remote: #{context}, base: #{result.context_base || result.base}"}
+          # log_debug("parse") {"remote: #{context}, base: #{result.context_base || result.base}"}
 
           # 3.2.1) Set context to the result of resolving value against the base IRI which is established as specified in section 5.1 Establishing a Base URI of [RFC3986]. 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].
           context = RDF::URI(result.context_base || base).join(context)
@@ -297,13 +297,14 @@ module JSON::LD
 
           cached_context = if PRELOADED[context_canon.to_s]
             # If we have a cached context, merge it into the current context (result) and use as the new context
-            log_debug("parse") {"=> cached_context: #{context_canon.to_s.inspect}"}
+            # log_debug("parse") {"=> cached_context: #{context_canon.to_s.inspect}"}
 
             # If this is a Proc, then replace the entry with the result of running the Proc
             if PRELOADED[context_canon.to_s].respond_to?(:call)
-              log_debug("parse") {"=> (call)"}
+              # log_debug("parse") {"=> (call)"}
               PRELOADED[context_canon.to_s] = PRELOADED[context_canon.to_s].call
             end
+            PRELOADED[context_canon.to_s].context_base ||= context_canon.to_s
             PRELOADED[context_canon.to_s]
           else
             # Load context document, if it is a string
@@ -478,7 +479,7 @@ module JSON::LD
         remote_contexts: [],
         validate_scoped: true)
       # Expand a string value, unless it matches a keyword
-      log_debug("create_term_definition") {"term = #{term.inspect}"}
+      # log_debug("create_term_definition") {"term = #{term.inspect}"}
 
       # If defined contains the key term, then the associated value must be true, indicating that the term definition has already been created, so return. Otherwise, a cyclical term definition has been detected, which is an error.
       case defined[term]
@@ -523,7 +524,7 @@ module JSON::LD
 
       raise JsonLdError::InvalidTermDefinition, "Term definition for #{term.inspect} is an #{value.class} on term #{term.inspect}" unless value.is_a?(Hash)
 
-      #log_debug("") {"Hash[#{term.inspect}] = #{value.inspect}"}
+      # log_debug("") {"Hash[#{term.inspect}] = #{value.inspect}"}
       definition = TermDefinition.new(term)
       definition.simple = simple_term
 
@@ -565,7 +566,7 @@ module JSON::LD
         elsif !JSON_LD_10_TYPE_VALUES.include?(type) && !(type.is_a?(RDF::URI) && type.absolute?)
           raise JsonLdError::InvalidTypeMapping, "unknown mapping for '@type': #{type.inspect} on term #{term.inspect}"
         end
-        #log_debug("") {"type_mapping: #{type.inspect}"}
+        # log_debug("") {"type_mapping: #{type.inspect}"}
         definition.type_mapping = type
       end
 
@@ -649,7 +650,7 @@ module JSON::LD
           # Otherwise, term is an absolute IRI. Set the IRI mapping for definition to term
           term
         end
-        log_debug("") {"=> #{definition.id}"}
+        # log_debug("") {"=> #{definition.id}"}
       elsif term.include?('/')
         # If term is a relative IRI
         definition.id = expand_iri(term, vocab: true)
@@ -662,13 +663,13 @@ module JSON::LD
         # Otherwise, active context must have a vocabulary mapping, otherwise an invalid value has been detected, which is an error. Set the IRI mapping for definition to the result of concatenating the value associated with the vocabulary mapping and term.
         raise JsonLdError::InvalidIRIMapping, "relative term definition without vocab: #{term} on term #{term.inspect}" unless vocab
         definition.id = vocab + term
-        log_debug("") {"=> #{definition.id}"}
+        # log_debug("") {"=> #{definition.id}"}
       end
 
       @iri_to_term[definition.id] = term if simple_term && definition.id
 
       if value.key?('@container')
-        #log_debug("") {"container_mapping: #{value['@container'].inspect}"}
+        # log_debug("") {"container_mapping: #{value['@container'].inspect}"}
         definition.container_mapping = check_container(value['@container'], local_context, defined, term)
 
         # If @container includes @type
@@ -702,7 +703,7 @@ module JSON::LD
           when nil then [nil]
           else value['@context']
           end
-          log_debug("") {"context: #{definition.context.inspect}"}
+          # log_debug("") {"context: #{definition.context.inspect}"}
         rescue JsonLdError => e
           raise JsonLdError::InvalidScopedContext, "Term definition for #{term.inspect} contains illegal value for @context: #{e.message}"
         end
@@ -722,14 +723,14 @@ module JSON::LD
         else
           raise JsonLdError::InvalidLanguageMapping, "language must be null or a string, was #{value['@language'].inspect}} on term #{term.inspect}"
         end
-        #log_debug("") {"language_mapping: #{language.inspect}"}
+        # log_debug("") {"language_mapping: #{language.inspect}"}
         definition.language_mapping = language || false
       end
 
       if value.key?('@direction')
         direction = value['@direction']
         raise JsonLdError::InvalidBaseDirection, "direction must be null, 'ltr', or 'rtl', was #{language.inspect}} on term #{term.inspect}" unless direction.nil? || %w(ltr rtl).include?(direction)
-        #log_debug("") {"direction_mapping: #{direction.inspect}"}
+        # log_debug("") {"direction_mapping: #{direction.inspect}"}
         definition.direction_mapping = direction || false
       end
 
@@ -737,7 +738,7 @@ module JSON::LD
         nest = value['@nest']
         raise JsonLdError::InvalidNestValue, "nest must be a string, was #{nest.inspect}} on term #{term.inspect}" unless nest.is_a?(String)
         raise JsonLdError::InvalidNestValue, "nest must not be a keyword other than @nest, was #{nest.inspect}} on term #{term.inspect}" if nest.match?(/^@[a-zA-Z]+$/) && nest != '@nest'
-        #log_debug("") {"nest: #{nest.inspect}"}
+        # log_debug("") {"nest: #{nest.inspect}"}
         definition.nest = nest
       end
 
@@ -897,22 +898,21 @@ module JSON::LD
     # @param  [Hash{Symbol => Object}] options ({})
     # @return [Hash]
     def serialize(provided_context: nil, **options)
-      #log_debug("serlialize: generate context")
-      #log_debug("") {"=> context: #{inspect}"}
+      # log_debug("serlialize: generate context")
+      # log_debug("") {"=> context: #{inspect}"}
       use_context = case provided_context
       when String, RDF::URI
-        #log_debug "serlialize: reuse context: #{provided_context.inspect}"
+        # log_debug "serlialize: reuse context: #{provided_context.inspect}"
         provided_context.to_s
       when Hash
-        #log_debug "serlialize: reuse context: #{provided_context.inspect}"
+        # log_debug "serlialize: reuse context: #{provided_context.inspect}"
         # If it has an @context entry use it, otherwise it is assumed to be the body of a context
         provided_context.fetch('@context', provided_context)
       when Array
-        #log_debug "serlialize: reuse context: #{provided_context.inspect}"
+        # log_debug "serlialize: reuse context: #{provided_context.inspect}"
         provided_context
       when IO, StringIO
-        provided_context.rewind
-        JSON.load(provided_context).fetch('@context', {})
+        load_context(provided_context, **@options).fetch('@context', {})
       else
         ctx = {}
         ctx['@version'] = 1.1 if @processingMode == 'json-ld-1.1'
@@ -1015,7 +1015,7 @@ module JSON::LD
     #
     # @return [TermDefinition]
     def set_mapping(term, value)
-      #log_debug("") {"map #{term.inspect} to #{value.inspect}"}
+      # log_debug("") {"map #{term.inspect} to #{value.inspect}"}
       term = term.to_s
       term_definitions[term] = TermDefinition.new(term, id: value, simple: true, prefix: (value.to_s.end_with?(*PREFIX_URI_ENDINGS)))
       term_definitions[term].simple = true
@@ -1467,8 +1467,6 @@ module JSON::LD
       end
     end
 
-    RDF_LITERAL_NATIVE_TYPES = Set.new([RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double]).freeze
-
     ##
     # If active property has a type mapping in the active context set to @id or @vocab, a JSON object with a single member @id whose value is the result of using the IRI Expansion algorithm on value is returned.
     #
@@ -1491,7 +1489,7 @@ module JSON::LD
 
       # If the active property has a type mapping in active context that is @id, return a new JSON object containing a single key-value pair where the key is @id and the value is the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
       if value.is_a?(String) && td.type_mapping == '@id'
-        #log_debug("") {"as relative IRI: #{value.inspect}"}
+        # log_debug("") {"as relative IRI: #{value.inspect}"}
         return {'@id' => expand_iri(value, documentRelative: true, base: base).to_s}
       end
 
@@ -1500,50 +1498,12 @@ module JSON::LD
         return {'@id' => expand_iri(value, vocab: true, documentRelative: true, base: base).to_s}
       end
 
-      value = RDF::Literal(value) if
-        value.is_a?(Date) ||
-        value.is_a?(DateTime) ||
-        value.is_a?(Time)
-
       result = case value
       when RDF::URI, RDF::Node
         {'@id' => value.to_s}
-      when RDF::Literal
-        res = {}
-        if value.datatype == RDF::URI(RDF.to_uri + "JSON") && processingMode('json-ld-1.1')
-          # Value parsed as JSON
-          # FIXME: MultiJson
-          res['@type'] = '@json'
-          res['@value'] = ::JSON.parse(value.object)
-        elsif value.datatype.start_with?("https://www.w3.org/ns/i18n#") && rdfDirection == 'i18n-datatype' && processingMode('json-ld-1.1')
-          lang, dir = value.datatype.fragment.split('_')
-          res['@value'] = value.to_s
-          unless lang.empty?
-            if lang !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
-              if options[:validate]
-                raise JsonLdError::InvalidLanguageMapping, "rdf:language must be valid BCP47: #{lang.inspect}"
-              else
-                warn "rdf:language must be valid BCP47: #{lang.inspect}"
-              end
-            end
-            res['@language'] = lang
-          end
-          res['@direction'] = dir
-        elsif useNativeTypes && RDF_LITERAL_NATIVE_TYPES.include?(value.datatype) && value.valid?
-          res['@type'] = uri(coerce(property)) if coerce(property)
-          res['@value'] = value.object
-        else
-          value.canonicalize! if value.valid? && value.datatype == RDF::XSD.double
-          if coerce(property)
-            res['@type'] = uri(coerce(property)).to_s
-          elsif value.datatype?
-            res['@type'] = uri(value.datatype).to_s
-          elsif value.language? || language(property)
-            res['@language'] = (value.language || language(property)).to_s
-          end
-          res['@value'] = value.to_s
-        end
-        res
+      when Date, DateTime, Time
+        lit = RDF::Literal.new(value)
+        {'@value' => lit.to_s, '@type' => lit.datatype.to_s}
       else
         # Otherwise, initialize result to a JSON object with an @value member whose value is set to value.
         res = {}
@@ -1561,8 +1521,6 @@ module JSON::LD
       end
 
       result
-    rescue ::JSON::ParserError => e
-      raise JSON::LD::JsonLdError::InvalidJsonLiteral, e.message
     end
 
     ##
@@ -1579,7 +1537,7 @@ module JSON::LD
     # @see https://www.w3.org/TR/json-ld11-api/#value-compaction
     # FIXME: revisit the specification version of this.
     def compact_value(property, value, base: nil)
-      #log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
+      # log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
       indexing = index?(value) && container(property).include?('@index')
       language = language(property)
@@ -1588,25 +1546,25 @@ module JSON::LD
       result = case
       when coerce(property) == '@id' && value.key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
-        #log_debug("") {" (@id & coerce)"}
+        # log_debug("") {" (@id & coerce)"}
         compact_iri(value['@id'], base: base)
       when coerce(property) == '@vocab' && value.key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
-        #log_debug("") {" (@id & coerce & vocab)"}
+        # log_debug("") {" (@id & coerce & vocab)"}
         compact_iri(value['@id'], vocab: true)
       when value.key?('@id')
-        #log_debug("") {" (@id)"}
+        # log_debug("") {" (@id)"}
         # return value as is
         value
       when value['@type'] && value['@type'] == coerce(property)
         # Compact common datatype
-        #log_debug("") {" (@type & coerce) == #{coerce(property)}"}
+        # log_debug("") {" (@type & coerce) == #{coerce(property)}"}
         value['@value']
       when coerce(property) == '@none' || value['@type']
         # use original expanded value
         value
       when !value['@value'].is_a?(String)
-        #log_debug("") {" (native)"}
+        # log_debug("") {" (native)"}
         indexing || !index?(value) ? value['@value'] : value
       when value['@language'].to_s.downcase == language.to_s.downcase && value['@direction'] == direction
         # Compact language and direction
@@ -1627,7 +1585,7 @@ module JSON::LD
       
       # If the result is an object, tranform keys using any term keyword aliases
       if result.is_a?(Hash) && result.keys.any? {|k| self.alias(k) != k}
-        #log_debug("") {" (map to key aliases)"}
+        # log_debug("") {" (map to key aliases)"}
         new_element = {}
         result.each do |k, v|
           new_element[self.alias(k)] = v
@@ -1635,7 +1593,7 @@ module JSON::LD
         result = new_element
       end
 
-      #log_debug("") {"=> #{result.inspect}"}
+      # log_debug("") {"=> #{result.inspect}"}
       result
     end
 
@@ -1731,11 +1689,21 @@ module JSON::LD
     CONTEXT_BASE_FRAG_OR_QUERY = %w(? #).freeze
     CONTEXT_TYPE_ID_VOCAB = %w(@id @vocab).freeze
 
+    ##
+    # Reads the `@context` from an IO
+    def load_context(io, **options)
+      io.rewind
+      remote_doc = API.loadRemoteDocument(io, **options)
+      remote_doc.document.is_a?(String) ?
+        MultiJson.load(remote_doc.document) :
+        remote_doc.document
+    end
+
     def uri(value)
       case value.to_s
       when /^_:(.*)$/
         # Map BlankNodes if a namer is given
-        #log_debug "uri(bnode)#{value}: #{$1}"
+        # log_debug "uri(bnode)#{value}: #{$1}"
         bnode(namer.get_sym($1))
       else
         value = RDF::URI(value)
@@ -1854,25 +1822,25 @@ module JSON::LD
     #   for the type mapping or language mapping
     # @return [String]
     def select_term(iri, containers, type_language, preferred_values)
-      #log_debug("select_term") {
+      # log_debug("select_term") {
       #  "iri: #{iri.inspect}, " +
       #  "containers: #{containers.inspect}, " +
       #  "type_language: #{type_language.inspect}, " +
       #  "preferred_values: #{preferred_values.inspect}"
       #}
       container_map = inverse_context[iri]
-      #log_debug("  ") {"container_map: #{container_map.inspect}"}
+      # log_debug("  ") {"container_map: #{container_map.inspect}"}
       containers.each do |container|
         next unless container_map.key?(container)
         tl_map = container_map[container]
         value_map = tl_map[type_language]
         preferred_values.each do |item|
           next unless value_map.key?(item)
-          #log_debug("=>") {value_map[item].inspect}
+          # log_debug("=>") {value_map[item].inspect}
           return value_map[item]
         end
       end
-      #log_debug("=>") {"nil"}
+      # log_debug("=>") {"nil"}
       nil
     end