json-ld 3.1.6 → 3.1.10

data/lib/json/ld/context.rb

@@ -253,6 +253,7 @@ module JSON::LD
 
       local_context = as_array(local_context)
 
+      log_depth do
       local_context.each do |context|
         case context
         when nil,false
@@ -266,22 +267,22 @@ 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)
             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
-            #log_debug("parse") {"Failed to parse @context from remote document at #{context}: #{e.message}"}
+            log_info("parse") {"Failed to parse @context from remote document at #{context}: #{e.message}"}
             raise JSON::LD::JsonLdError::InvalidRemoteContext, "Failed to parse remote context at #{context}: #{e.message}" if @options[:validate]
             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)
@@ -296,11 +297,11 @@ 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]
@@ -314,22 +315,23 @@ 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
                 ctx.context_base = context.to_s
                 ctx = ctx.parse(remote_doc.document['@context'], remote_contexts: remote_contexts.dup)
+                ctx.context_base = context.to_s # In case it was altered
                 ctx.instance_variable_set(:@base, nil)
                 ctx
               end
             rescue JsonLdError::LoadingDocumentFailed => e
-              #log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
+              log_info("parse") {"Failed to retrieve @context from remote document at #{context_canon.inspect}: #{e.message}"}
               raise JsonLdError::LoadingRemoteContextFailed, "#{context}: #{e.message}", e.backtrace
             rescue JsonLdError
               raise
             rescue StandardError => e
-              #log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
+              log_info("parse") {"Failed to retrieve @context from remote document at #{context_canon.inspect}: #{e.message}"}
               raise JsonLdError::LoadingRemoteContextFailed, "#{context}: #{e.message}", e.backtrace
             end
           end
@@ -352,7 +354,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 +369,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
@@ -406,6 +408,7 @@ module JSON::LD
           raise JsonLdError::InvalidLocalContext, "must be a URL, JSON object or array of same: #{context.inspect}"
         end
       end
+      end
       result
     end
 
@@ -475,7 +478,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]
@@ -542,7 +545,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 +569,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 +595,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 +603,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 +640,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.
@@ -646,7 +649,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)
@@ -659,12 +662,12 @@ 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.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 +682,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,
@@ -699,12 +702,13 @@ module JSON::LD
           when nil then [nil]
           else value['@context']
           end
+          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
       end
 
-      if value.has_key?('@language')
+      if value.key?('@language')
         language = value['@language']
         language = case value['@language']
         when String
@@ -722,14 +726,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 +741,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 +1022,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
@@ -1038,7 +1042,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
@@ -1134,7 +1138,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 +1186,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 +1216,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 +1291,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 +1302,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 +1316,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 +1348,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 +1363,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 +1391,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 +1417,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 +1431,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?
@@ -1455,6 +1459,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
@@ -1523,16 +1529,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 +1586,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 +1615,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 +1863,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
@@ -1882,7 +1888,7 @@ module JSON::LD
       @base_and_parents ||= begin
         u = base
         iri_set = u.to_s.end_with?('/') ? [u.to_s] : []
-        iri_set << u.to_s while (u = u.parent)
+        iri_set << u.to_s while (u != './' && u = u.parent)
         iri_set
       end
       b = base.to_s

data/lib/json/ld/expand.rb

@@ -11,9 +11,9 @@ module JSON::LD
     # The following constant is used to reduce object allocations
     CONTAINER_INDEX_ID_TYPE = Set['@index', '@id', '@type'].freeze
     KEY_ID = %w(@id).freeze
-    KEYS_VALUE_LANGUAGE_TYPE_INDEX_DIRECTION = %w(@value @language @type @index @direction).freeze
+    KEYS_VALUE_LANGUAGE_TYPE_INDEX_DIRECTION = %w(@value @language @type @index @direction @annotation).freeze
     KEYS_SET_LIST_INDEX = %w(@set @list @index).freeze
-    KEYS_INCLUDED_TYPE = %w(@included @type).freeze
+    KEYS_INCLUDED_TYPE_REVERSE = %w(@included @type @reverse).freeze
 
     ##
     # Expand an Array or Object given an active context and performing local context expansion.
@@ -49,7 +49,13 @@ module JSON::LD
             log_depth: log_depth.to_i + 1)
 
           # If the active property is @list or its container mapping is set to @list and v is an array, change it to a list object
-          v = {"@list" => v} if is_list && v.is_a?(Array)
+          if is_list && v.is_a?(Array)
+            # Make sure that no member of v contains an annotation object
+            raise JsonLdError::InvalidAnnotation,
+              "A list element must not contain @annotation." if
+              v.any? {|n| n.is_a?(Hash) && n.key?('@annotation')}
+            v = {"@list" => v}
+          end
 
           case v
           when nil then nil
@@ -81,7 +87,7 @@ module JSON::LD
         log_debug("expand", depth: log_depth.to_i) {"after property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
 
         # If element contains the key @context, set active context to the result of the Context Processing algorithm, passing active context and the value of the @context key as local context.
-        if input.has_key?('@context')
+        if input.key?('@context')
           context = context.parse(input.delete('@context'), base: @options[:base])
           log_debug("expand", depth: log_depth.to_i) {"context: #{context.inspect}"}
         end
@@ -101,7 +107,7 @@ module JSON::LD
           Array(input[tk]).sort.each do |term|
             term_context = type_scoped_context.term_definitions[term].context if type_scoped_context.term_definitions[term]
             unless term_context.nil?
-              log_debug("expand", depth: log_depth.to_i) {"term_context: #{term_context.inspect}"}
+              log_debug("expand", depth: log_depth.to_i) {"term_context[#{term}]: #{term_context.inspect}"}
               context = context.parse(term_context, base: @options[:base], propagate: false)
             end
           end
@@ -142,7 +148,7 @@ module JSON::LD
 
           if output_object['@type'] == '@json' && context.processingMode('json-ld-1.1')
             # Any value of @value is okay if @type: @json
-          elsif !ary.all? {|v| v.is_a?(String) || v.is_a?(Hash) && v.empty?} && output_object.has_key?('@language')
+          elsif !ary.all? {|v| v.is_a?(String) || v.is_a?(Hash) && v.empty?} && output_object.key?('@language')
             # Otherwise, if the value of result's @value member is not a string and result contains the key @language, an invalid language-tagged value error has been detected (only strings can be language-tagged) and processing is aborted.
             raise JsonLdError::InvalidLanguageTaggedValue,
                   "when @language is used, @value must be a string: #{output_object.inspect}"
@@ -172,6 +178,18 @@ module JSON::LD
 
           # If result contains the key @set, then set result to the key's associated value.
           return output_object['@set'] if output_object.key?('@set')
+        elsif output_object['@annotation']
+          # Otherwise, if result contains the key @annotation,
+          # the array value must all be node objects without an @id property, otherwise, an invalid annotation error has been detected and processing is aborted.
+          raise JsonLdError::InvalidAnnotation,
+            "@annotation must reference node objects without @id." unless
+            output_object['@annotation'].all? {|o| node?(o) && !o.key?('@id')}
+
+          # Additionally, the property must not be used if there is no active property, or the expanded active property is @graph.
+          raise JsonLdError::InvalidAnnotation,
+            "@annotation must not be used on a top-level object." if
+            %w(@graph @included).include?(expanded_active_property || '@graph')
+          
         end
 
         # If result contains only the key @language, set result to null.
@@ -240,10 +258,10 @@ module JSON::LD
           expanded_property.to_s.start_with?("_:") &&
           context.processingMode('json-ld-1.1')
 
-        #log_debug("expand property", depth: log_depth.to_i) {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
+        log_debug("expand property", depth: log_depth.to_i) {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
 
         if expanded_property.nil?
-          #log_debug(" => ", depth: log_depth.to_i) {"skip nil property"}
+          log_debug(" => ", depth: log_depth.to_i) {"skip nil property"}
           next
         end
 
@@ -254,10 +272,15 @@ module JSON::LD
 
           # If result has already an expanded property member (other than @type), an colliding keywords error has been detected and processing is aborted.
           raise JsonLdError::CollidingKeywords,
-                "#{expanded_property} already exists in result" if output_object.has_key?(expanded_property) && !KEYS_INCLUDED_TYPE.include?(expanded_property)
+                "#{expanded_property} already exists in result" if output_object.key?(expanded_property) && !KEYS_INCLUDED_TYPE_REVERSE.include?(expanded_property)
 
           expanded_value = case expanded_property
           when '@id'
+            # If expanded active property is `@annotation`, an invalid annotation error has been found and processing is aborted.
+            raise JsonLdError::InvalidAnnotation,
+              "an annotation must not contain a property expanding to @id" if
+              expanded_active_property == '@annotation' && @options[:rdfstar]
+
             # If expanded property is @id and value is not a string, an invalid @id value error has been detected and processing is aborted
             e_id = case value
             when String
@@ -280,7 +303,11 @@ module JSON::LD
                 [{}]
               elsif @options[:rdfstar]
                 # Result must have just a single statement
-                rei_node = expand(value, active_property, context, log_depth: log_depth.to_i + 1)
+                rei_node = expand(value, nil, context, log_depth: log_depth.to_i + 1)
+
+                # Node must not contain @reverse
+                raise JsonLdError::InvalidEmbeddedNode,
+                      "Embedded node with @reverse" if rei_node && rei_node.key?('@reverse')
                 statements = to_enum(:item_to_rdf, rei_node)
                 raise JsonLdError::InvalidEmbeddedNode,
                       "Embedded node with #{statements.size} statements" unless
@@ -314,7 +341,7 @@ module JSON::LD
             Array(output_object['@included']) + included_result
           when '@type'
             # If expanded property is @type and value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, true for vocab, and true for document relative to expand the value or each of its items.
-            #log_debug("@type", depth: log_depth.to_i) {"value: #{value.inspect}"}
+            log_debug("@type", depth: log_depth.to_i) {"value: #{value.inspect}"}
             e_type = case value
             when Array
               value.map do |v|
@@ -465,6 +492,11 @@ module JSON::LD
             # Spec FIXME: need to be sure that result is an array
             value = as_array(value)
 
+            # Make sure that no member of value contains an annotation object
+            raise JsonLdError::InvalidAnnotation,
+              "A list element must not contain @annotation." if
+              value.any? {|n| n.is_a?(Hash) && n.key?('@annotation')}
+
             value
           when '@set'
             # If expanded property is @set, set expanded value to the result of using this algorithm recursively, passing active context, active property, and value for element.
@@ -483,8 +515,8 @@ module JSON::LD
               log_depth: log_depth.to_i + 1)
 
             # If expanded value contains an @reverse member, i.e., properties that are reversed twice, execute for each of its property and item the following steps:
-            if value.has_key?('@reverse')
-              #log_debug("@reverse", depth: log_depth.to_i) {"double reverse: #{value.inspect}"}
+            if value.key?('@reverse')
+              log_debug("@reverse", depth: log_depth.to_i) {"double reverse: #{value.inspect}"}
               value['@reverse'].each do |property, item|
                 # If result does not have a property member, create one and set its value to an empty array.
                 # Append item to the value of the property member of result.
@@ -522,13 +554,19 @@ module JSON::LD
             nests << key
             # Continue with the next key from element
             next
+          when '@annotation'
+            # Skip unless rdfstar option is set
+            next unless @options[:rdfstar]
+            as_array(expand(value, '@annotation', context,
+              framing: framing,
+              log_depth: log_depth.to_i + 1))
           else
             # Skip unknown keyword
             next
           end
 
           # Unless expanded value is null, set the expanded property member of result to expanded value.
-          #log_debug("expand #{expanded_property}", depth: log_depth.to_i) { expanded_value.inspect}
+          log_debug("expand #{expanded_property}", depth: log_depth.to_i) { expanded_value.inspect}
           output_object[expanded_property] = expanded_value unless expanded_value.nil? && expanded_property == '@value' && input_type != '@json'
           next
         end
@@ -650,21 +688,21 @@ module JSON::LD
 
         # If expanded value is null, ignore key by continuing to the next key from element.
         if expanded_value.nil?
-          #log_debug(" => skip nil value", depth: log_depth.to_i)
+          log_debug(" => skip nil value", depth: log_depth.to_i)
           next
         end
-        #log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
+        log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
 
         # If the container mapping associated to key in active context is @list and expanded value is not already a list object, convert expanded value to a list object by first setting it to an array containing only expanded value if it is not already an array, and then by setting it to a JSON object containing the key-value pair @list-expanded value.
         if container.first == '@list' && container.length == 1 && !list?(expanded_value)
-          #log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
+          log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
           expanded_value = {'@list' => as_array(expanded_value)}
         end
-        #log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
+        log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
 
         # convert expanded value to @graph if container specifies it
         if container.first == '@graph' && container.length == 1
-          #log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
+          log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
           expanded_value = as_array(expanded_value).map do |v|
             {'@graph' => as_array(v)}
           end