json-ld 3.1.7 → 3.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9345f0853c9ee6d7e1bb91817ca7d9effc1ce5d591f98fa92a11c396c1f0fbb
-  data.tar.gz: 7a84d8f7b4dd0fe379dd8b915d6e899f610807959d9ea4ef66c0ab4c22657807
+  metadata.gz: 8fab787ba5efd37b20576d65d5dfe524923f14c7dac53a1d9ed32cb88bd689c8
+  data.tar.gz: 3b8ce473fe9e05302dabedb9a631ca2212aeb03479cc2d282abf8603daeedce2
 SHA512:
-  metadata.gz: d2ff1429edeea61f1655e445862140b5477dfa978cfaeaa3a417417fff24adfc17b6adea77cb24041c8c3daafaf7661d05023a3f1e2e4c161194be7dc4c96dd7
-  data.tar.gz: e04b64a78d9bfdc88d808219440b758540a3e6bd2f7dae4ee73831b093ab8ada77641acfc2c4c079b413f17b0d88a0149058fa3959c2fbdd6e0d421c8885fa5a
+  metadata.gz: 47ec226ef3c0d79702d61a7fa81ce2ed3368f64744e2fb29f1b98fdaae2aba7e6af7ed493395031eb43d89e4469c04a24ea38ad836baffb50a46854cf33a75c8
+  data.tar.gz: 579b1794485469d832b29a2f5f5bbf36819627d93289595da6f46e2197829e4e6365a5bbb4c88193f904ad07a21a643821195d22cb3750543e6954e986d809f4

data/README.md

@@ -4,7 +4,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/json-ld.png)](https://rubygems.org/gems/json-ld)
 [![Build Status](https://secure.travis-ci.org/ruby-rdf/json-ld.png?branch=develop)](https://github.com/ruby-rdf/json-ld/actions?query=workflow%3ACI)
-[![Coverage Status](https://coveralls.io/repos/ruby-rdf/json-ld/badge.svg)](https://coveralls.io/github/ruby-rdf/json-ld)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/json-ld/badge.svg?branch=develop)](https://coveralls.io/github/ruby-rdf/json-ld?branch=develop)
 [![Gitter chat](https://badges.gitter.im/ruby-rdf.png)](https://gitter.im/gitterHQ/gitter)
 
 ## Features
@@ -17,7 +17,7 @@ JSON::LD can now be used to create a _context_ from an RDFS/OWL definition, and
 * If available, uses [Nokogiri][] and/or [Nokogumbo][] for parsing HTML, falls back to REXML otherwise.
 * Provisional support for [JSON-LD*][JSON-LD*].
 
-[Implementation Report](file.earl.html)
+[Implementation Report](https://ruby-rdf.github.io/json-ld/etc/earl.html)
 
 Install with `gem install json-ld`
 
@@ -39,7 +39,7 @@ The [MultiJson](https://rubygems.org/gems/multi_json) gem is used for parsing JS
 
 ### JSON-LD* (RDFStar)
 
-The {JSON::LD::API.toRdf} and {JSON::LD::API.fromRdf} API methods, along with the {JSON::LD::Reader} and {JSON::LD::Writer}, include provisional support for [JSON-LD*][JSON-LD*].
+The {JSON::LD::API.expand}, {JSON::LD::API.compact}, {JSON::LD::API.toRdf}, and {JSON::LD::API.fromRdf} API methods, along with the {JSON::LD::Reader} and {JSON::LD::Writer}, include provisional support for [JSON-LD*][JSON-LD*].
 
 Internally, an `RDF::Statement` is treated as another resource, along with `RDF::URI` and `RDF::Node`, which allows an `RDF::Statement` to have a `#subject` or `#object` which is also an `RDF::Statement`.
 
@@ -55,6 +55,19 @@ In JSON-LD, with the `rdfstar` option set, the value of `@id`, in addition to an
       "ex:certainty": 0.9
     }
 
+Additionally, the `@annotation` property (or alias) may be used on a node object or value object to annotate the statement for which the associated node is the object of a triple.
+
+    {
+      "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+      "@id": "bob",
+      "foaf:age" 23,
+      "@annotation": {
+        "ex:certainty": 0.9
+      }
+    }
+
+In the first case, the embedded node is not asserted, and only appears as the subject of a triple. In the second case, the triple is asserted and used as the subject in another statement which annotates it.
+
 **Note: This feature is subject to change or elimination as the standards process progresses.**
 
 #### Serializing a Graph containing embedded statements

data/VERSION

@@ -1 +1 @@
-3.1.7
+3.1.8

data/bin/jsonld

@@ -24,7 +24,7 @@ def run(input, options, parser_options)
 
   start = Time.new
   if options[:expand]
-    parser_options = parser_options.merge(expandContext: parser_options.delete(:context)) if parser_options.has_key?(:context)
+    parser_options = parser_options.merge(expandContext: parser_options.delete(:context)) if parser_options.key?(:context)
     input = JSON::LD::API.fromRdf(reader) if reader
     output = JSON::LD::API.expand(input, parser_options)
     secs = Time.new - start
@@ -49,7 +49,7 @@ def run(input, options, parser_options)
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Framed in #{secs} seconds." unless options[:quiet]
   else
-    parser_options = parser_options.merge(expandContext: parser_options.delete(:context)) if parser_options.has_key?(:context)
+    parser_options = parser_options.merge(expandContext: parser_options.delete(:context)) if parser_options.key?(:context)
     parser_options[:standard_prefixes] = true
     reader ||= JSON::LD::Reader.new(input, parser_options)
     num = 0
@@ -181,7 +181,7 @@ opts.each do |opt, arg|
 end
 
 # Hack
-if !(options.keys & [:expand, :compact, :flatten, :frame]).empty? &&
+if !(options.keys & %i{expand compact flatten frame}).empty? &&
    (parser_options[:stream] || options[:output_format] != :jsonld)
    STDERR.puts "Incompatible options"
    exit(1)

data/lib/json/ld.rb

@@ -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,7 +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 reified node"; 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

@@ -102,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
@@ -202,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
@@ -248,9 +250,9 @@ 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
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The flattened JSON-LD document
@@ -275,6 +277,9 @@ 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)
@@ -316,6 +321,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.
@@ -325,7 +331,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
@@ -391,10 +396,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')
 
@@ -415,7 +423,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
 
@@ -458,10 +466,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
@@ -470,7 +478,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
@@ -480,16 +488,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

@@ -64,7 +64,7 @@ module JSON::LD
           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("", depth: log_depth.to_i) {"=> scalar result: #{result.inspect}"}
@@ -231,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
@@ -276,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

data/lib/json/ld/context.rb

@@ -314,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
@@ -352,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")
@@ -367,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
@@ -542,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
@@ -566,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
@@ -592,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
@@ -600,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)
 
@@ -637,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.
@@ -664,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)
 
@@ -679,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,
@@ -704,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
@@ -722,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'
@@ -737,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
@@ -1018,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
@@ -1134,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)
@@ -1182,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
 
@@ -1212,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
 
@@ -1287,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
@@ -1298,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"
@@ -1312,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"
@@ -1344,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'
 
@@ -1359,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
@@ -1387,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)
@@ -1413,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.
@@ -1427,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?
@@ -1523,16 +1523,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
@@ -1580,15 +1580,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
@@ -1609,7 +1609,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)}
@@ -1857,11 +1857,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