json-ld 3.1.4 → 3.1.9

data/lib/json/ld.rb

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 # frozen_string_literal: true
 $:.unshift(File.expand_path("../ld", __FILE__))
-require 'rdf' # @see http://rubygems.org/gems/rdf
+require 'rdf' # @see https://rubygems.org/gems/rdf
 require 'multi_json'
 require 'set'
 
@@ -19,7 +19,7 @@ module JSON
   #     end
   #   end
   #
-  # @see http://rubygems.org/gems/rdf
+  # @see https://rubygems.org/gems/rdf
   # @see http://www.w3.org/TR/REC-rdf-syntax/
   #
   # @author [Gregg Kellogg](http://greggkellogg.net/)
@@ -47,6 +47,7 @@ module JSON
     DEFAULT_CONTEXT = "http://schema.org"
 
     KEYWORDS = Set.new(%w(
+      @annotation
       @base
       @container
       @context
@@ -116,6 +117,7 @@ module JSON
       class CollidingKeywords < JsonLdError; @code = "colliding keywords"; end
       class ConflictingIndexes < JsonLdError; @code = "conflicting indexes"; end
       class CyclicIRIMapping < JsonLdError; @code = "cyclic IRI mapping"; end
+      class InvalidAnnotation < JsonLdError; @code = "invalid annotation"; end
       class InvalidBaseIRI < JsonLdError; @code = "invalid base IRI"; end
       class InvalidContainerMapping < JsonLdError; @code = "invalid container mapping"; end
       class InvalidContextEntry < JsonLdError; @code = "invalid context entry"; end
@@ -137,6 +139,7 @@ module JSON
       class InvalidNestValue < JsonLdError; @code = "invalid @nest value"; end
       class InvalidPrefixValue < JsonLdError; @code = "invalid @prefix value"; end
       class InvalidPropagateValue < JsonLdError; @code = "invalid @propagate value"; end
+      class InvalidEmbeddedNode < JsonLdError; @code = "invalid embedded node"; end
       class InvalidRemoteContext < JsonLdError; @code = "invalid remote context"; end
       class InvalidReverseProperty < JsonLdError; @code = "invalid reverse property"; end
       class InvalidReversePropertyMap < JsonLdError; @code = "invalid reverse property map"; end

data/lib/json/ld/api.rb

@@ -89,6 +89,8 @@ module JSON::LD
     # @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)
+    #   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)
@@ -100,13 +102,15 @@ module JSON::LD
     # @yield [api]
     # @yieldparam [API]
     # @raise [JsonLdError]
-    def initialize(input, context, rename_bnodes: true, unique_bnodes: false, **options, &block)
+    def initialize(input, context, **options, &block)
       @options = {
         compactArrays:      true,
         ordered:            false,
         extractAllScripts:  false,
+        rename_bnodes:      true,
+        unique_bnodes:      false,
       }.merge(options)
-      @namer = unique_bnodes ? BlankNodeUniqer.new : (rename_bnodes ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
+      @namer = @options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
       @options[:base] = RDF::URI(@options[:base]) if @options[:base] && !@options[:base].is_a?(RDF::URI)
       # For context via Link header
@@ -200,9 +204,9 @@ module JSON::LD
     #   The JSON-LD object to copy and perform the compaction upon.
     # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   The base context to use when compacting the input.
+    # @param [Boolean] expanded (false) Input is already expanded
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
-    # @option options [Boolean] :expanded Input is already expanded
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The compacted JSON-LD document
@@ -246,9 +250,11 @@ module JSON::LD
     #   The JSON-LD object or array of JSON-LD objects to flatten or an IRI referencing the JSON-LD document to flatten.
     # @param [String, #read, Hash, Array, JSON::LD::EvaluationContext] context
     #   An optional external context to use additionally to the context embedded in input when expanding the input.
+    # @param [Boolean] expanded (false) Input is already expanded
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
-    # @option options [Boolean] :expanded Input is already expanded
+    # @option options [Boolean] :createAnnotations
+    #   Unfold embedded nodes which can be represented using `@annotation`.
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The flattened JSON-LD document
@@ -273,10 +279,20 @@ module JSON::LD
       API.new(expanded_input, context, no_default_base: true, **options) do
         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]
+
         # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
         graph_maps = {'@default' => {}}
         create_node_map(value, graph_maps)
 
+        # If create annotations flag is set, then update each node map in graph maps with the result of calling the create annotations algorithm.
+        if options[:createAnnotations]
+          graph_maps.values.each do |node_map|
+            create_annotations(node_map)
+          end
+        end
+
         default_graph = graph_maps['@default']
         graph_maps.keys.opt_sort(ordered: @options[:ordered]).each do |graph_name|
           next if graph_name == '@default'
@@ -295,7 +311,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))
-          kwgraph = self.context.compact_iri('@graph')
+          kwgraph = self.context.compact_iri('@graph', vocab: true)
           flattened = self.context.
             serialize(provided_context: context).
             merge(kwgraph => compacted)
@@ -314,6 +330,7 @@ module JSON::LD
     #   The JSON-LD object to copy and perform the framing on.
     # @param [String, #read, Hash, Array] frame
     #   The frame to use when re-arranging the data.
+    # @param [Boolean] expanded (false) Input is already expanded
     # @option options (see #initialize)
     # @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.
@@ -323,7 +340,6 @@ module JSON::LD
     #   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.
-    # @option options [Boolean] :expanded Input is already expanded
     # @option options [Boolean] :pruneBlankNodeIdentifiers (true) removes blank node identifiers that are only used once.
     # @option options [Boolean] :omitGraph does not use `@graph` at top level unless necessary to describe multiple objects, defaults to `true` if processingMode is 1.1, otherwise `false`.
     # @yield jsonld
@@ -389,10 +405,13 @@ module JSON::LD
         end
 
         # Set omitGraph option, if not present, based on processingMode
-        unless options.has_key?(:omitGraph)
+        unless options.key?(:omitGraph)
           options[:omitGraph] = context.processingMode('json-ld-1.1')
         end
 
+        # 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)
+
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
         create_node_map(value, framing_state[:graphMap], active_graph: '@default')
 
@@ -413,7 +432,7 @@ module JSON::LD
         frame(framing_state, framing_state[:subjects].keys.opt_sort(ordered: @options[:ordered]), (expanded_frame.first || {}), parent: result, **options)
 
         # Default to based on processinMode
-        if !options.has_key?(:pruneBlankNodeIdentifiers)
+        if !options.key?(:pruneBlankNodeIdentifiers)
           options[:pruneBlankNodeIdentifiers] = context.processingMode('json-ld-1.1')
         end
 
@@ -438,7 +457,7 @@ module JSON::LD
         result = if !compacted.is_a?(Array)
           compacted
         else
-          kwgraph = context.compact_iri('@graph')
+          kwgraph = context.compact_iri('@graph', vocab: true)
           {kwgraph => compacted}
         end
         # Only add context if one was provided
@@ -456,10 +475,10 @@ module JSON::LD
     #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to process when outputting statements.
+    # @param [Boolean] expanded (false) Input is already expanded
     # @option options (see #initialize)
     # @option options [Boolean] :produceGeneralizedRdf (false)
     #   If true, output will include statements having blank node predicates, otherwise they are dropped.
-    # @option options [Boolean] :expanded Input is already expanded
     # @raise [JsonLdError]
     # @yield statement
     # @yieldparam [RDF::Statement] statement
@@ -468,7 +487,7 @@ module JSON::LD
       unless block_given?
         results = []
         results.extend(RDF::Enumerable)
-        self.toRdf(input, **options) do |stmt|
+        self.toRdf(input, expanded: expanded, **options) do |stmt|
           results << stmt
         end
         return results
@@ -478,16 +497,16 @@ module JSON::LD
         extractAllScripts:  true,
       }.merge(options)
 
-      # Expand input to simplify processing
-      expanded_input = expanded ? input : API.expand(input, ordered: false, **options)
+      # Flatten input to simplify processing
+      flattened_input = API.flatten(input, nil, expanded: expanded, ordered: false, **options)
 
-      API.new(expanded_input, nil, **options) do
+      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") {"expanded input: #{expanded_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
-        expanded_input.each do |node|
+        flattened_input.each do |node|
           item_to_rdf(node) do |statement|
             next if statement.predicate.node? && !options[:produceGeneralizedRdf]
 

data/lib/json/ld/compact.rb

@@ -19,12 +19,9 @@ module JSON::LD
     # @return [Array, Hash]
     def compact(element,
                 base: nil,
-                property: nil)
-      #if property.nil?
-      #  log_debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
-      #else
-      #  log_debug("compact") {"property: #{property.inspect}"}
-      #end
+                property: nil,
+                log_depth: nil)
+      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
@@ -33,7 +30,7 @@ module JSON::LD
       when Array
         #log_debug("") {"Array #{element.inspect}"}
         result = element.map do |item|
-          compact(item, base: base, property: property)
+          compact(item, base: base, property: property, log_depth: log_depth.to_i + 1)
         end.compact
 
         # If element has a single member and the active property has no
@@ -41,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: #{result.first.inspect}")
+          log_debug("=> extract single element", depth: log_depth.to_i) {result.first.inspect}
           result.first
         else
-          #log_debug("=> array result: #{result.inspect}")
+          log_debug("=> array result", depth: log_depth.to_i) {result.inspect}
           result
         end
       when Hash
@@ -55,6 +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}"}
           self.context = context.previous_context
         end
 
@@ -63,12 +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}"}
         end
 
-        if element.key?('@id') || element.key?('@value')
+        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("") {"=> scalar result: #{result.inspect}"}
+            log_debug("", depth: log_depth.to_i) {"=> scalar result: #{result.inspect}"}
             return result
           end
         end
@@ -76,7 +75,8 @@ module JSON::LD
         # 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).include?('@list')
           return compact(element['@list'], base: base,
-                         property: property)
+                         property: property,
+                         log_depth: log_depth.to_i + 1)
         end
 
         inside_reverse = property == '@reverse'
@@ -90,15 +90,23 @@ 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}"}
         end
 
         element.keys.opt_sort(ordered: @options[:ordered]).each do |expanded_property|
           expanded_value = element[expanded_property]
-          #log_debug("") {"#{expanded_property}: #{expanded_value.inspect}"}
+          log_debug("", depth: log_depth.to_i) {"#{expanded_property}: #{expanded_value.inspect}"}
 
           if expanded_property == '@id'
-            compacted_value = Array(expanded_value).map do |expanded_id|
-              context.compact_iri(expanded_id, base: @options[:base])
+            compacted_value = as_array(expanded_value).map do |expanded_id|
+              if node?(expanded_id) && @options[:rdfstar]
+                # This can only really happen for valid RDF-star
+                compact(expanded_id, base: base,
+                        property: '@id',
+                        log_depth: log_depth.to_i + 1)
+              else
+                context.compact_iri(expanded_id, base: @options[:base])
+              end
             end
 
             kw_alias = context.compact_iri('@id', vocab: true)
@@ -124,8 +132,9 @@ module JSON::LD
 
           if expanded_property == '@reverse'
             compacted_value = compact(expanded_value, base: base,
-                                      property: '@reverse')
-            #log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
+                                      property: '@reverse',
+                                      log_depth: log_depth.to_i + 1)
+            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)
@@ -136,8 +145,8 @@ module JSON::LD
             end
 
             unless compacted_value.empty?
-              al = context.compact_iri('@reverse')
-              #log_debug("") {"remainder: #{al} => #{compacted_value.inspect}"}
+              al = context.compact_iri('@reverse', vocab: true)
+              log_debug("", depth: log_depth.to_i) {"remainder: #{al} => #{compacted_value.inspect}"}
               result[al] = compacted_value
             end
             next
@@ -146,8 +155,9 @@ module JSON::LD
           if expanded_property == '@preserve'
             # Compact using `property`
             compacted_value = compact(expanded_value, base: base,
-                                      property: property)
-            #log_debug("@preserve") {"compacted_value: #{compacted_value.inspect}"}
+                                      property: property,
+                                      log_depth: log_depth.to_i + 1)
+            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
@@ -156,14 +166,14 @@ module JSON::LD
           end
 
           if expanded_property == '@index' && context.container(property).include?('@index')
-            #log_debug("@index") {"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) {"#{al} => #{expanded_value.inspect}"}
+            log_debug(expanded_property, depth: log_depth.to_i) {"#{al} => #{expanded_value.inspect}"}
             result[al] = expanded_value
             next
           end
@@ -211,8 +221,9 @@ module JSON::LD
             end
 
             compacted_item = compact(value, base: base,
-                                     property: item_active_property)
-            #log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
+                                     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}"}
 
             # handle @list
             if list?(expanded_item)
@@ -220,7 +231,7 @@ module JSON::LD
               unless container.include?('@list')
                 al = context.compact_iri('@list', vocab: true)
                 compacted_item = {al => compacted_item}
-                if expanded_item.has_key?('@index')
+                if expanded_item.key?('@index')
                   key = context.compact_iri('@index', vocab: true)
                   compacted_item[key] = expanded_item['@index']
                 end
@@ -265,7 +276,7 @@ module JSON::LD
                   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')
+                if expanded_item.key?('@index')
                   key = context.compact_iri('@index', vocab: true)
                   compacted_item[key] = expanded_item['@index']
                 end
@@ -315,7 +326,8 @@ module JSON::LD
                 if compacted_item.keys.length == 1 && expanded_item.keys.include?('@id')
                   compacted_item = compact({'@id' => expanded_item['@id']},
                                            base: base,
-                                           property: item_active_property)
+                                           property: item_active_property,
+                                           log_depth: log_depth.to_i + 1)
                 end
                 compacted_item
               end
@@ -332,7 +344,7 @@ module JSON::LD
         result
       else
         # For other types, the compacted value is the element value
-        #log_debug("compact") {element.class.to_s}
+        log_debug("compact", depth: log_depth.to_i) {element.class.to_s}
         element
       end
 

data/lib/json/ld/conneg.rb

@@ -46,7 +46,7 @@ module JSON::LD
     #
     # @param  [Hash{String => String}] env
     # @return [Array(Integer, Hash, #each)] Status, Headers and Body
-    # @see    http://rack.rubyforge.org/doc/SPEC.html
+    # @see    https://rubydoc.info/github/rack/rack/file/SPEC
     def call(env)
       response = app.call(env)
       body = response[2].respond_to?(:body) ? response[2].body : response[2]

data/lib/json/ld/context.rb

@@ -104,16 +104,12 @@ module JSON::LD
     # @see #initialize
     # @see #parse
     # @param [String, #read, Array, Hash, Context] local_context
-    # @param [String, #to_s] :base (nil)
+    # @param [String, #to_s] base (nil)
     #   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.
-    # @param [Proc] :documentLoader (nil)
-    #   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 {API.documentLoader} for the method signature.
     # @param [Boolean] override_protected (false)
     #   Protected terms may be cleared.
     # @param [Boolean] propagate (true)
     #   If false, retains any previously defined term, which can be rolled back when the descending into a new node object changes.
-    # @param [Boolean] validate (false)
-    #   Extra validatation
     # @raise [JsonLdError]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
     # @return [Context]
@@ -231,14 +227,12 @@ module JSON::LD
     #
     #
     # @param [String, #read, Array, Hash, Context] local_context
-    # @param [String, #to_s] :base
+    # @param [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.
     # @param [Boolean] override_protected Protected terms may be cleared.
     # @param [Boolean] propagate (true)
     #   If false, retains any previously defined term, which can be rolled back when the descending into a new node object changes.
     # @param [Array<String>] remote_contexts ([])
-    # @param [Boolean] validate (false)
-    #   Extra validatation
     # @param [Boolean] validate_scoped (true).
     #   Validate scoped context, loading if necessary.
     #   If false, do not load scoped contexts.
@@ -320,7 +314,7 @@ module JSON::LD
               #context_opts.delete(:headers)
               JSON::LD::API.loadRemoteDocument(context.to_s, **context_opts) do |remote_doc|
                 # 3.2.5) Dereference context. If the dereferenced document has no top-level JSON object with an @context member, an invalid remote context has been detected and processing is aborted; otherwise, set context to the value of that member.
-                raise JsonLdError::InvalidRemoteContext, "#{context}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.has_key?('@context')
+                raise JsonLdError::InvalidRemoteContext, "#{context}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.key?('@context')
 
                 # Parse stand-alone
                 ctx = Context.new(unfrozen: true, **options).dup
@@ -358,7 +352,7 @@ module JSON::LD
             '@propagate'  => :propagate=,
             '@vocab'      => :vocab=,
           }.each do |key, setter|
-            next unless context.has_key?(key)
+            next unless context.key?(key)
             if key == '@import'
               # Retrieve remote context and merge the remaining context object into the result.
               raise JsonLdError::InvalidContextEntry, "@import may only be used in 1.1 mode}" if result.processingMode("json-ld-1.0")
@@ -373,11 +367,11 @@ module JSON::LD
                 # FIXME: should cache this, but ContextCache is for parsed contexts
                 JSON::LD::API.loadRemoteDocument(import_loc, **context_opts) do |remote_doc|
                   # Dereference import_loc. If the dereferenced document has no top-level JSON object with an @context member, an invalid remote context has been detected and processing is aborted; otherwise, set context to the value of that member.
-                  raise JsonLdError::InvalidRemoteContext, "#{import_loc}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.has_key?('@context')
+                  raise JsonLdError::InvalidRemoteContext, "#{import_loc}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.key?('@context')
                   import_context = remote_doc.document['@context']
                   import_context.delete('@base')
                   raise JsonLdError::InvalidRemoteContext, "#{import_context.to_json} must be an object" unless import_context.is_a?(Hash)
-                  raise JsonLdError::InvalidContextEntry, "#{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.key?('@import')
                   context.delete(key)
                   context = import_context.merge(context)
                 end
@@ -419,9 +413,7 @@ module JSON::LD
     # Merge in a context, creating a new context with updates from `context`
     #
     # @param [Context] context
-    # @param [Boolean] protected mark resulting context as protected
     # @param [Boolean] override_protected Allow or disallow protected terms to be changed
-    # @param [Boolean]
     # @return [Context]
     def merge(context, override_protected: false)
       ctx = Context.new(term_definitions: self.term_definitions, standard_prefixes: options[:standard_prefixes])
@@ -469,8 +461,6 @@ module JSON::LD
     # @param [String, RDF::URI] base for resolving document-relative IRIs
     # @param [Boolean] protected if true, causes all terms to be marked protected
     # @param [Boolean] override_protected Protected terms may be cleared.
-    # @param [Boolean] propagate
-    #   Context is propagated across node objects.
     # @param [Array<String>] remote_contexts
     # @param [Boolean] validate_scoped (true).
     #   Validate scoped context, loading if necessary.
@@ -552,7 +542,7 @@ module JSON::LD
       # Potentially note that the term is protected
       definition.protected = value.fetch('@protected', protected)
 
-      if value.has_key?('@type')
+      if value.key?('@type')
         type = value['@type']
         # SPEC FIXME: @type may be nil
         type = case type
@@ -576,7 +566,7 @@ module JSON::LD
         definition.type_mapping = type
       end
 
-      if value.has_key?('@reverse')
+      if value.key?('@reverse')
         raise JsonLdError::InvalidReverseProperty, "unexpected key in #{value.inspect} on term #{term.inspect}" if
           value.key?('@id') || value.key?('@nest')
         raise JsonLdError::InvalidIRIMapping, "expected value of @reverse to be a string: #{value['@reverse'].inspect} on term #{term.inspect}" unless
@@ -602,7 +592,7 @@ module JSON::LD
         warn "[DEPRECATION] Blank Node terms deprecated in JSON-LD 1.1." if @options[:validate] && processingMode('json-ld-1.1') && definition.id.to_s.start_with?("_:")
 
         # If value contains an @container member, set the container mapping of definition to its value; if its value is neither @set, @index, @type, @id, an absolute IRI nor null, an invalid reverse property error has been detected (reverse properties only support set- and index-containers) and processing is aborted.
-        if value.has_key?('@container')
+        if value.key?('@container')
           container = value['@container']
           raise JsonLdError::InvalidReverseProperty,
                 "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" unless
@@ -610,9 +600,9 @@ module JSON::LD
           definition.container_mapping = check_container(container, local_context, defined, term)
         end
         definition.reverse_property = true
-      elsif value.has_key?('@id') && value['@id'].nil?
+      elsif value.key?('@id') && value['@id'].nil?
         # Allowed to reserve a null term, which may be protected
-      elsif value.has_key?('@id') && value['@id'] != term
+      elsif value.key?('@id') && value['@id'] != term
         raise JsonLdError::InvalidIRIMapping, "expected value of @id to be a string: #{value['@id'].inspect} on term #{term.inspect}" unless
           value['@id'].is_a?(String)
 
@@ -647,7 +637,7 @@ module JSON::LD
       elsif term[1..-1].include?(':')
         # If term is a compact IRI with a prefix that is a key in local context then a dependency has been found. Use this algorithm recursively passing active context, local context, the prefix as term, and defined.
         prefix, suffix = term.split(':', 2)
-        create_term_definition(local_context, prefix, defined, protected: protected) if local_context.has_key?(prefix)
+        create_term_definition(local_context, prefix, defined, protected: protected) if local_context.key?(prefix)
 
         definition.id = if td = term_definitions[prefix]
           # If term's prefix has a term definition in active context, set the IRI mapping for definition to the result of concatenating the value associated with the prefix's IRI mapping and the term's suffix.
@@ -674,7 +664,7 @@ module JSON::LD
 
       @iri_to_term[definition.id] = term if simple_term && definition.id
 
-      if value.has_key?('@container')
+      if value.key?('@container')
         #log_debug("") {"container_mapping: #{value['@container'].inspect}"}
         definition.container_mapping = check_container(value['@container'], local_context, defined, term)
 
@@ -689,14 +679,14 @@ module JSON::LD
         end
       end
 
-      if value.has_key?('@index')
+      if value.key?('@index')
         # property-based indexing
         raise JsonLdError::InvalidTermDefinition, "@index without @index in @container: #{value['@index']} on term #{term.inspect}" unless definition.container_mapping.include?('@index')
         raise JsonLdError::InvalidTermDefinition, "@index must expand to an IRI: #{value['@index']} on term #{term.inspect}" unless value['@index'].is_a?(String) && !value['@index'].start_with?('@')
         definition.index = value['@index'].to_s
       end
 
-      if value.has_key?('@context')
+      if value.key?('@context')
         begin
           new_ctx = self.parse(value['@context'],
                                base: base,
@@ -714,7 +704,7 @@ module JSON::LD
         end
       end
 
-      if value.has_key?('@language')
+      if value.key?('@language')
         language = value['@language']
         language = case value['@language']
         when String
@@ -732,14 +722,14 @@ module JSON::LD
         definition.language_mapping = language || false
       end
 
-      if value.has_key?('@direction')
+      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}"}
         definition.direction_mapping = direction || false
       end
 
-      if value.has_key?('@nest')
+      if value.key?('@nest')
         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'
@@ -747,7 +737,7 @@ module JSON::LD
         definition.nest = nest
       end
 
-      if value.has_key?('@prefix')
+      if value.key?('@prefix')
         raise JsonLdError::InvalidTermDefinition, "@prefix used on compact or relative IRI term #{term.inspect}" if term.match?(%r{:|/})
         case pfx = value['@prefix']
         when TrueClass, FalseClass
@@ -846,7 +836,7 @@ module JSON::LD
     # If contex has a @version member, it's value MUST be 1.1, otherwise an "invalid @version value" has been detected, and processing is aborted.
     # If processingMode has been set, and it is not "json-ld-1.1", a "processing mode conflict" has been detecting, and processing is aborted.
     #
-    # @param [String, Number] expected
+    # @param [String, Number] value
     # @return [String]
     # @raise [JsonLdError::ProcessingModeConflict]
     def processingMode=(value = nil, **options)
@@ -1028,7 +1018,7 @@ module JSON::LD
 
       term_sym = term.empty? ? "" : term.to_sym
       iri_to_term.delete(term_definitions[term].id.to_s) if term_definitions[term].id.is_a?(String)
-      @options[:prefixes][term_sym] = value if @options.has_key?(:prefixes)
+      @options[:prefixes][term_sym] = value if @options.key?(:prefixes)
       iri_to_term[value.to_s] = term
       term_definitions[term]
     end
@@ -1048,7 +1038,7 @@ module JSON::LD
     # @param [Term, #to_s] term in unexpanded form
     # @return [Array<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>]
     def container(term)
-      return [term] if term == '@list'
+      return Set[term] if term == '@list'
       term = find_definition(term)
       term ? term.container_mapping : Set.new
     end
@@ -1144,7 +1134,7 @@ module JSON::LD
     # @return [Term] related term definition
     def reverse_term(term)
       # Direct lookup of term
-      term = term_definitions[term.to_s] if term_definitions.has_key?(term.to_s) && !term.is_a?(TermDefinition)
+      term = term_definitions[term.to_s] if term_definitions.key?(term.to_s) && !term.is_a?(TermDefinition)
 
       # Lookup term, assuming term is an IRI
       unless term.is_a?(TermDefinition)
@@ -1192,7 +1182,7 @@ module JSON::LD
       defined = defined || {} # if we initialized in the keyword arg we would allocate {} at each invokation, even in the 2 (common) early returns above.
 
       # If local context is not null, it contains a key that equals value, and the value associated with the key that equals value in defined is not true, then invoke the Create Term Definition subalgorithm, passing active context, local context, value as term, and defined. This will ensure that a term definition is created for value in active context during Context Processing.
-      if local_context && local_context.has_key?(value) && !defined[value]
+      if local_context && local_context.key?(value) && !defined[value]
         create_term_definition(local_context, value, defined)
       end
 
@@ -1222,7 +1212,7 @@ module JSON::LD
         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]
+        if local_context && local_context.key?(prefix) && !defined[prefix]
           create_term_definition(local_context, prefix, defined)
         end
 
@@ -1297,7 +1287,7 @@ module JSON::LD
       return if iri.nil?
       iri = iri.to_s
 
-      if vocab && inverse_context.has_key?(iri)
+      if vocab && inverse_context.key?(iri)
         default_language = if self.default_direction
           "#{self.default_language}_#{self.default_direction}".downcase
         else
@@ -1308,7 +1298,7 @@ module JSON::LD
         containers.concat(CONTAINERS_INDEX_SET) if index?(value) && !graph?(value)
 
         # If the value is a JSON Object with the key @preserve, use the value of @preserve.
-        value = value['@preserve'].first if value.is_a?(Hash) && value.has_key?('@preserve')
+        value = value['@preserve'].first if value.is_a?(Hash) && value.key?('@preserve')
 
         if reverse
           tl, tl_value = "@type", "@reverse"
@@ -1322,11 +1312,11 @@ module JSON::LD
           list.each do |item|
             item_language, item_type = "@none", "@none"
             if value?(item)
-              if item.has_key?('@direction')
+              if item.key?('@direction')
                 item_language = "#{item['@language']}_#{item['@direction']}".downcase
-              elsif item.has_key?('@language')
+              elsif item.key?('@language')
                 item_language = item['@language'].downcase
-              elsif item.has_key?('@type')
+              elsif item.key?('@type')
                 item_type = item['@type']
               else
                 item_language = "@null"
@@ -1354,14 +1344,14 @@ module JSON::LD
         elsif graph?(value)
           # Prefer @index and @id containers, then @graph, then @index
           containers.concat(CONTAINERS_GRAPH_INDEX_INDEX) if index?(value)
-          containers.concat(CONTAINERS_GRAPH) if value.has_key?('@id')
+          containers.concat(CONTAINERS_GRAPH) if value.key?('@id')
 
           # Prefer an @graph container next
           containers.concat(CONTAINERS_GRAPH_SET)
 
           # Lastly, in 1.1, any graph can be indexed on @index or @id, so add if we haven't already
           containers.concat(CONTAINERS_GRAPH_INDEX) unless index?(value)
-          containers.concat(CONTAINERS_GRAPH) unless value.has_key?('@id')
+          containers.concat(CONTAINERS_GRAPH) unless value.key?('@id')
           containers.concat(CONTAINERS_INDEX_SET) unless index?(value)
           containers << '@set'
 
@@ -1369,13 +1359,13 @@ module JSON::LD
         else
           if value?(value)
             # In 1.1, an language map can be used to index values using @none
-            if value.has_key?('@language') && !index?(value)
+            if value.key?('@language') && !index?(value)
               tl_value = value['@language'].downcase
               tl_value += "_#{value['@direction']}" if value['@direction']
               containers.concat(CONTAINERS_LANGUAGE)
-            elsif value.has_key?('@direction') && !index?(value)
+            elsif value.key?('@direction') && !index?(value)
               tl_value = "_#{value['@direction']}"
-            elsif value.has_key?('@type')
+            elsif value.key?('@type')
               tl_value = value['@type']
               tl = '@type'
             end
@@ -1397,7 +1387,7 @@ module JSON::LD
         tl_value ||= '@null'
         preferred_values = []
         preferred_values << '@reverse' if tl_value == '@reverse'
-        if (tl_value == '@id' || tl_value == '@reverse') && value.is_a?(Hash) && value.has_key?('@id')
+        if (tl_value == '@id' || tl_value == '@reverse') && value.is_a?(Hash) && value.key?('@id')
           t_iri = compact_iri(value['@id'], vocab: true, base: base)
           if (r_td = term_definitions[t_iri]) && r_td.id == value['@id']
             preferred_values.concat(CONTAINERS_VOCAB_ID)
@@ -1423,7 +1413,7 @@ 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]
-        return suffix unless term_definitions.has_key?(suffix)
+        return suffix unless term_definitions.key?(suffix)
       end
 
       # The iri could not be compacted using the active context's vocabulary mapping. Try to create a compact IRI, starting by initializing compact IRI to null. This variable will be used to tore the created compact IRI, if any.
@@ -1437,7 +1427,7 @@ module JSON::LD
 
         suffix = iri[td.id.length..-1]
         ciri = "#{term}:#{suffix}"
-        candidates << ciri unless value && term_definitions.has_key?(ciri)
+        candidates << ciri unless value && term_definitions.key?(ciri)
       end
 
       return candidates.sort.first if !candidates.empty?
@@ -1465,6 +1455,8 @@ module JSON::LD
       if !vocab
         # transform iri to a relative IRI using the document's base IRI
         iri = remove_base(self.base || base, iri)
+        # Make . relative if it has the form of a keyword.
+        iri = "./#{iri}" if iri.match?(/^@[a-zA-Z]+$/)
         return iri
       else
         return iri
@@ -1533,16 +1525,16 @@ module JSON::LD
             res['@language'] = lang
           end
           res['@direction'] = dir
-        elsif useNativeTypes && RDF_LITERAL_NATIVE_TYPES.include?(value.datatype)
+        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.datatype == RDF::XSD.double
+          value.canonicalize! if value.valid? && value.datatype == RDF::XSD.double
           if coerce(property)
             res['@type'] = uri(coerce(property)).to_s
-          elsif value.has_datatype?
+          elsif value.datatype?
             res['@type'] = uri(value.datatype).to_s
-          elsif value.has_language? || language(property)
+          elsif value.language? || language(property)
             res['@language'] = (value.language || language(property)).to_s
           end
           res['@value'] = value.to_s
@@ -1590,15 +1582,15 @@ module JSON::LD
       direction = direction(property)
 
       result = case
-      when coerce(property) == '@id' && value.has_key?('@id') && (value.keys - %w(@id @index)).empty?
+      when coerce(property) == '@id' && value.key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
         #log_debug("") {" (@id & coerce)"}
         compact_iri(value['@id'], base: base)
-      when coerce(property) == '@vocab' && value.has_key?('@id') && (value.keys - %w(@id @index)).empty?
+      when coerce(property) == '@vocab' && value.key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
         #log_debug("") {" (@id & coerce & vocab)"}
         compact_iri(value['@id'], vocab: true)
-      when value.has_key?('@id')
+      when value.key?('@id')
         #log_debug("") {" (@id)"}
         # return value as is
         value
@@ -1619,7 +1611,7 @@ module JSON::LD
         value
       end
 
-      if result.is_a?(Hash) && result.has_key?('@type') && value['@type'] != '@json'
+      if result.is_a?(Hash) && result.key?('@type') && value['@type'] != '@json'
         # Compact values of @type
         c_type =  if result['@type'].is_a?(Array)
           result['@type'].map {|t| compact_iri(t, vocab: true)}
@@ -1867,11 +1859,11 @@ module JSON::LD
       container_map = inverse_context[iri]
       #log_debug("  ") {"container_map: #{container_map.inspect}"}
       containers.each do |container|
-        next unless container_map.has_key?(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.has_key?(item)
+          next unless value_map.key?(item)
           #log_debug("=>") {value_map[item].inspect}
           return value_map[item]
         end
@@ -2064,7 +2056,7 @@ module JSON::LD
       # @param ["ltr", "rtl"] direction_mapping
       #   Direction mapping of term, `false` is used if there is an explicit direction mapping for this term
       # @param [Boolean] reverse_property
-      # @param [Boolean] protected
+      # @param [Boolean] protected mark resulting context as protected
       # @param [String] nest term used for nest properties
       # @param [Boolean] simple
       #   This is a simple term definition, not an expanded term definition