json-ld 3.1.0 → 3.1.5

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/)
@@ -34,6 +34,8 @@ module JSON
     autoload :Normalize,          'json/ld/normalize'
     autoload :Reader,             'json/ld/reader'
     autoload :Resource,           'json/ld/resource'
+    autoload :StreamingReader,    'json/ld/streaming_reader'
+    autoload :StreamingWriter,    'json/ld/streaming_writer'
     autoload :VERSION,            'json/ld/version'
     autoload :Writer,             'json/ld/writer'
 
@@ -52,13 +54,13 @@ module JSON
       @direction
       @embed
       @explicit
-      @json
-      @id
-      @included
-      @index
       @first
       @graph
+      @id
       @import
+      @included
+      @index
+      @json
       @language
       @list
       @nest
@@ -66,6 +68,7 @@ module JSON
       @omitDefault
       @propagate
       @protected
+      @preserve
       @requireAll
       @reverse
       @set
@@ -115,7 +118,7 @@ module JSON
       class CyclicIRIMapping < JsonLdError; @code = "cyclic IRI mapping"; end
       class InvalidBaseIRI < JsonLdError; @code = "invalid base IRI"; end
       class InvalidContainerMapping < JsonLdError; @code = "invalid container mapping"; end
-      class InvalidContextMember < JsonLdError; @code = "invalid context member"; end
+      class InvalidContextEntry < JsonLdError; @code = "invalid context entry"; end
       class InvalidContextNullification < JsonLdError; @code = "invalid context nullification"; end
       class InvalidDefaultLanguage < JsonLdError; @code = "invalid default language"; end
       class InvalidIdValue < JsonLdError; @code = "invalid @id value"; end
@@ -142,6 +145,7 @@ module JSON
       class InvalidScopedContext < JsonLdError; @code = "invalid scoped context"; end
       class InvalidScriptElement < JsonLdError; @code = "invalid script element"; end
       class InvalidSetOrListObject < JsonLdError; @code = "invalid set or list object"; end
+      class InvalidStreamingKeyOrder < JsonLdError; @code = 'invalid streaming key order' end
       class InvalidTermDefinition < JsonLdError; @code = "invalid term definition"; end
       class InvalidBaseDirection < JsonLdError; @code = "invalid base direction"; end
       class InvalidTypedValue < JsonLdError; @code = "invalid typed value"; end
@@ -154,7 +158,7 @@ module JSON
       class KeywordRedefinition < JsonLdError; @code = "keyword redefinition"; end
       class LoadingDocumentFailed < JsonLdError; @code = "loading document failed"; end
       class LoadingRemoteContextFailed < JsonLdError; @code = "loading remote context failed"; end
-      class ContextOverflow < JsonLdError; @code = "maximum number of @context URLs exceeded"; end
+      class ContextOverflow < JsonLdError; @code = "context overflow"; end
       class MissingIncludedReferent < JsonLdError; @code = "missing @included referent"; end
       class MultipleContextLinkHeaders < JsonLdError; @code = "multiple context link headers"; end
       class ProtectedTermRedefinition < JsonLdError; @code = "protected term redefinition"; end

data/lib/json/ld/api.rb

@@ -35,7 +35,7 @@ module JSON::LD
 
     # Options used for open_file
     OPEN_OPTS = {
-      headers: {"Accept" => "application/ld+json, text/html;q=0.8, application/json;q=0.5"}
+      headers: {"Accept" => "application/ld+json, text/html;q=0.8, application/xhtml+xml;q=0.8, application/json;q=0.5"}
     }
 
     # The following constants are used to reduce object allocations
@@ -66,7 +66,7 @@ module JSON::LD
     # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   An external context to use additionally to the context embedded in input when expanding the input.
     # @param  [Hash{Symbol => Object}] options
-    # @option options [String, #to_s] :base
+    # @option options [RDF::URI, String, #to_s] :base
     #   The Base IRI to use when expanding the document. This overrides the value of `input` if it is a _IRI_. If not specified and `input` is not an _IRI_, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from `input`, options[:base] will be modified with this value.
     # @option options [Boolean] :compactArrays (true)
     #   If set to `true`, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to `false`, all arrays will remain arrays even if they have just one element.
@@ -108,6 +108,7 @@ module JSON::LD
       }.merge(options)
       @namer = unique_bnodes ? BlankNodeUniqer.new : (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
       _, context_ref = nil, nil
 
@@ -117,7 +118,7 @@ module JSON::LD
         remote_doc = self.class.loadRemoteDocument(input, **@options)
 
         context_ref = remote_doc.contextUrl
-        @options[:base] = remote_doc.documentUrl if remote_doc.documentUrl && !@options[:no_default_base]
+        @options[:base] = RDF::URI(remote_doc.documentUrl) if remote_doc.documentUrl && !@options[:no_default_base]
 
         case remote_doc.document
         when String
@@ -130,7 +131,7 @@ module JSON::LD
 
       # If not provided, first use context from document, or from a Link header
       context ||= context_ref || {}
-      @context = Context.parse(context || {}, **@options)
+      @context = Context.parse(context, **@options)
 
       if block_given?
         case block.arity
@@ -163,10 +164,9 @@ module JSON::LD
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
     # @see https://www.w3.org/TR/json-ld11-api/#expansion-algorithm
     def self.expand(input, framing: false, **options, &block)
-      result, doc_base = nil
+      result = doc_base = nil
       API.new(input, options[:expandContext], **options) do
         result = self.expand(self.value, nil, self.context,
-          ordered: @options[:ordered],
           framing: framing)
         doc_base = @options[:base]
       end
@@ -218,21 +218,21 @@ module JSON::LD
       # 1) Perform the Expansion Algorithm on the JSON-LD input.
       #    This removes any existing context to allow the given context to be cleanly applied.
       expanded_input = expanded ? input : API.expand(input, ordered: false, **options) do |res, base_iri|
-        options[:base] ||= base_iri if options[:compactToRelative]
+        options[:base] ||= RDF::URI(base_iri) if base_iri && options[:compactToRelative]
         res
       end
 
       API.new(expanded_input, context, no_default_base: true, **options) do
         log_debug(".compact") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
-        result = compact(value, ordered: @options[:ordered])
+        result = compact(value)
 
         # xxx) Add the given context to the output
-        ctx = self.context.serialize
+        ctx = self.context.serialize(provided_context: context)
         if result.is_a?(Array)
-          kwgraph = self.context.compact_iri('@graph', vocab: true, quiet: true)
+          kwgraph = self.context.compact_iri('@graph', vocab: true)
           result = result.empty? ? {} : {kwgraph => result}
         end
-        result = ctx.merge(result) unless ctx.empty?
+        result = ctx.merge(result) unless ctx.fetch('@context', {}).empty?
       end
       block_given? ? yield(result) : result
     end
@@ -265,7 +265,7 @@ module JSON::LD
 
       # Expand input to simplify processing
       expanded_input = expanded ? input : API.expand(input, **options) do |result, base_iri|
-        options[:base] ||= base_iri if options[:compactToRelative]
+        options[:base] ||= RDF::URI(base_iri) if base_iri && options[:compactToRelative]
         result
       end
 
@@ -294,9 +294,11 @@ module JSON::LD
 
         if context && !flattened.empty?
           # Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result uses the @graph keyword (or its alias) at the top-level, even if the context is empty or if there is only one element to put in the @graph array. This ensures that the returned document has a deterministic structure.
-          compacted = as_array(compact(flattened, ordered: @options[:ordered]))
-          kwgraph = self.context.compact_iri('@graph', quiet: true)
-          flattened = self.context.serialize.merge(kwgraph => compacted)
+          compacted = as_array(compact(flattened))
+          kwgraph = self.context.compact_iri('@graph')
+          flattened = self.context.
+            serialize(provided_context: context).
+            merge(kwgraph => compacted)
         end
       end
 
@@ -313,11 +315,11 @@ module JSON::LD
     # @param [String, #read, Hash, Array] frame
     #   The frame to use when re-arranging the data.
     # @option options (see #initialize)
-    # @option options ['@always', '@first', '@last', '@link', '@once', '@never'] :embed ('@last')
+    # @option options ['@always', '@link', '@once', '@never'] :embed ('@once')
     #   a flag specifying that objects should be directly embedded in the output, instead of being referred to by their IRI.
     # @option options [Boolean] :explicit (false)
     #   a flag specifying that for properties to be included in the output, they must be explicitly declared in the framing context.
-    # @option options [Boolean] :requireAll (true)
+    # @option options [Boolean] :requireAll (false)
     #   A flag specifying that all properties present in the input frame must either have a default value or be present in the JSON-LD input for the frame to match.
     # @option options [Boolean] :omitDefault (false)
     #   a flag specifying that properties that are missing from the JSON-LD input should be omitted from the output.
@@ -335,7 +337,7 @@ module JSON::LD
     def self.frame(input, frame, expanded: false, **options)
       result = nil
       options = {
-        base:                       (input if input.is_a?(String)),
+        base:                       (RDF::URI(input) if input.is_a?(String)),
         compactArrays:              true,
         compactToRelative:          true,
         embed:                      '@once',
@@ -369,7 +371,7 @@ module JSON::LD
 
       # Expand input to simplify processing
       expanded_input = expanded ? input : API.expand(input, ordered: false, **options) do |res, base_iri|
-        options[:base] ||= base_iri if options[:compactToRelative]
+        options[:base] ||= RDF::URI(base_iri) if base_iri && options[:compactToRelative]
         res
       end
 
@@ -394,7 +396,7 @@ module JSON::LD
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
         create_node_map(value, framing_state[:graphMap], active_graph: '@default')
 
-        frame_keys = frame.keys.map {|k| context.expand_iri(k, vocab: true, quiet: true)}
+        frame_keys = frame.keys.map {|k| context.expand_iri(k, vocab: true)}
         if frame_keys.include?('@graph')
           # If frame contains @graph, it matches the default graph.
           framing_state[:graph] = '@default'
@@ -426,7 +428,7 @@ module JSON::LD
         log_debug(".frame") {"expanded result: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Compact result
-        compacted = compact(result, ordered: @options[:ordered])
+        compacted = compact(result)
 
         # @replace `@null` with nil, compacting arrays
         compacted = cleanup_null(compacted)
@@ -434,11 +436,14 @@ module JSON::LD
 
         # Add the given context to the output
         result = if !compacted.is_a?(Array)
-          context.serialize.merge(compacted)
+          compacted
         else
-          kwgraph = context.compact_iri('@graph', quiet: true)
-          context.serialize.merge({kwgraph => compacted})
+          kwgraph = context.compact_iri('@graph')
+          {kwgraph => compacted}
         end
+        # Only add context if one was provided
+        result = context.serialize(provided_context: frame).merge(result) if frame['@context']
+        
         log_debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
         result
       end
@@ -521,8 +526,7 @@ module JSON::LD
       API.new(nil, nil, **options) do
         result = from_statements(input,
           useRdfType: useRdfType,
-          useNativeTypes: useNativeTypes,
-          ordered: @options[:ordered])
+          useNativeTypes: useNativeTypes)
       end
 
       block_given? ? yield(result) : result
@@ -532,16 +536,18 @@ module JSON::LD
     # Uses built-in or provided documentLoader to retrieve a parsed document.
     #
     # @param [RDF::URI, String] url
+    # @param [String, RDF::URI] base
+    #   Location to use as documentUrl instead of `url`.
+    # @option options [Proc] :documentLoader
+    #   The callback of the loader to be used to retrieve remote documents and contexts.
     # @param [Boolean] extractAllScripts
     #   If set to `true`, when extracting JSON-LD script elements from HTML, unless a specific fragment identifier is targeted, extracts all encountered JSON-LD script elements using an array form, if necessary.
     # @param [String] profile
-    #   When the resulting `contentType` is `text/html`, this option determines the profile to use for selecting a JSON-LD script elements.
+    #   When the resulting `contentType` is `text/html` or `application/xhtml+xml`, this option determines the profile to use for selecting a JSON-LD script elements.
     # @param [String] requestProfile
     #   One or more IRIs to use in the request as a profile parameter.
-    # @param [Boolean] validate
+    # @param [Boolean] validate (false)
     #   Allow only appropriate content types
-    # @param [String, RDF::URI] base
-    #   Location to use as documentUrl instead of `url`.
     # @param [Hash<Symbol => Object>] options
     # @yield remote_document
     # @yieldparam [RemoteDocumentRemoteDocument, RDF::Util::File::RemoteDocument] remote_document
@@ -550,13 +556,14 @@ module JSON::LD
     #   If a block is given, the result of evaluating the block is returned, otherwise, the retrieved remote document and context information unless block given
     # @raise [JsonLdError]
     def self.loadRemoteDocument(url,
+                                base: nil,
+                                documentLoader: nil,
                                 extractAllScripts: false,
                                 profile: nil,
                                 requestProfile: nil,
                                 validate: false,
-                                base: nil,
                                 **options)
-      documentLoader = options.fetch(:documentLoader, self.method(:documentLoader))
+      documentLoader ||= self.method(:documentLoader)
       options = OPEN_OPTS.merge(options)
       if requestProfile
         # Add any request profile
@@ -612,7 +619,7 @@ module JSON::LD
         # Parse any HTML
         if remote_doc.document.is_a?(String)
           remote_doc.document = case remote_doc.contentType
-          when 'text/html'
+          when 'text/html', 'application/xhtml+xml'
             load_html(remote_doc.document,
                       url: remote_doc.documentUrl,
                       extractAllScripts: extractAllScripts,
@@ -628,7 +635,7 @@ module JSON::LD
 
         if remote_doc.contentType && validate
           raise IOError, "url: #{url}, contentType: #{remote_doc.contentType}" unless
-            remote_doc.contentType.match?(/application\/(.+\+)?json|text\/html/)
+            remote_doc.contentType.match?(/application\/(.+\+)?json|text\/html|application\/xhtml\+xml/)
         end
         block_given? ? yield(remote_doc) : remote_doc
       end
@@ -642,7 +649,7 @@ module JSON::LD
     # @param [Boolean] extractAllScripts
     #   If set to `true`, when extracting JSON-LD script elements from HTML, unless a specific fragment identifier is targeted, extracts all encountered JSON-LD script elements using an array form, if necessary.
     # @param [String] profile
-    #   When the resulting `contentType` is `text/html`, this option determines the profile to use for selecting a JSON-LD script elements.
+    #   When the resulting `contentType` is `text/html` or `application/xhtml+xml`, this option determines the profile to use for selecting a JSON-LD script elements.
     # @param [String] requestProfile
     #   One or more IRIs to use in the request as a profile parameter.
     # @param [Hash<Symbol => Object>] options
@@ -703,14 +710,14 @@ module JSON::LD
         require "json/ld/html/#{library}"
 
         # Parse HTML using the appropriate library
-        @implementation = case library
+        implementation = case library
         when :nokogiri then Nokogiri
         when :rexml then REXML
         end
-        self.extend(@implementation)
+        self.extend(implementation)
 
         input = begin
-          initialize_html(input, **options)
+          self.send("initialize_html_#{library}".to_sym, input, **options)
         rescue
           raise JSON::LD::JsonLdError::LoadingDocumentFailed, "Malformed HTML document: #{$!.message}"
         end
@@ -729,8 +736,8 @@ module JSON::LD
         id = CGI.unescape(url.fragment)
         # Find script with an ID based on that fragment.
         element = input.at_xpath("//script[@id='#{id}']")
-        raise JSON::LD::JsonLdError::InvalidScriptElement, "No script tag found with id=#{id}" unless element
-        raise JSON::LD::JsonLdError::InvalidScriptElement, "Script tag has type=#{element.attributes['type']}" unless element.attributes['type'].to_s.start_with?('application/ld+json')
+        raise JSON::LD::JsonLdError::LoadingDocumentFailed, "No script tag found with id=#{id}" unless element
+        raise JSON::LD::JsonLdError::LoadingDocumentFailed, "Script tag has type=#{element.attributes['type']}" unless element.attributes['type'].to_s.start_with?('application/ld+json')
         content = element.inner_html
         validate_input(content, url: url) if options[:validate]
         MultiJson.load(content, **options)
@@ -739,7 +746,7 @@ module JSON::LD
         elements = if profile
           es = input.xpath("//script[starts-with(@type, 'application/ld+json;profile=#{profile}')]")
           # If no profile script, just take a single script without profile
-          es = [input.at_xpath("//script[starts-with(@type, 'application/ld+json')]")] if es.empty?
+          es = [input.at_xpath("//script[starts-with(@type, 'application/ld+json')]")].compact if es.empty?
           es
         else
           input.xpath("//script[starts-with(@type, 'application/ld+json')]")
@@ -759,11 +766,12 @@ module JSON::LD
         # Find the first script with type application/ld+json.
         element = input.at_xpath("//script[starts-with(@type, 'application/ld+json;profile=#{profile}')]") if profile
         element ||= input.at_xpath("//script[starts-with(@type, 'application/ld+json')]")
-        content = element ? element.inner_html : "[]"
+        raise JSON::LD::JsonLdError::LoadingDocumentFailed, "No script tag found" unless element
+        content = element.inner_html
         validate_input(content, url: url) if options[:validate]
         MultiJson.load(content, **options)
       end
-    rescue JSON::LD::JsonLdError::LoadingDocumentFailed, MultiJson::ParseError => e
+    rescue MultiJson::ParseError => e
       raise JSON::LD::JsonLdError::InvalidScriptElement, e.message
     end
 

data/lib/json/ld/compact.rb

@@ -5,28 +5,23 @@ module JSON::LD
     include Utils
 
     # The following constant is used to reduce object allocations in #compact below
-    CONTAINER_MAPPING_ID = %w(@id).freeze
-    CONTAINER_MAPPING_INDEX = %w(@index).freeze
-    CONTAINER_MAPPING_LANGUAGE = %w(@language).freeze
     CONTAINER_MAPPING_LANGUAGE_INDEX_ID_TYPE = Set.new(%w(@language @index @id @type)).freeze
-    CONTAINER_MAPPING_LIST = %w(@list).freeze
-    CONTAINER_MAPPING_TYPE = %w(@type).freeze
     EXPANDED_PROPERTY_DIRECTION_INDEX_LANGUAGE_VALUE = %w(@direction @index @language @value).freeze
 
     ##
     # This algorithm compacts a JSON-LD document, such that the given context is applied. This must result in shortening any applicable IRIs to terms or compact IRIs, any applicable keywords to keyword aliases, and any applicable JSON-LD values expressed in expanded form to simple values such as strings or numbers.
     #
     # @param [Array, Hash] element
-    # @param [String] property (nil)
-    # @param [Boolean] ordered (true)
+    # @param [String, RDF::URI] base (nil)
     #   Ensure output objects have keys ordered properly
+    # @param [String] property (nil)
+    #   Extra validatation
     # @return [Array, Hash]
-    def compact(element, property: nil, ordered: false)
-      #if property.nil?
-      #  log_debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
-      #else
-      #  log_debug("compact") {"property: #{property.inspect}"}
-      #end
+    def compact(element,
+                base: nil,
+                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
@@ -34,17 +29,19 @@ module JSON::LD
       case element
       when Array
         #log_debug("") {"Array #{element.inspect}"}
-        result = element.map {|item| compact(item, property: property, ordered: ordered)}.compact
+        result = element.map do |item|
+          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
         # @container mapping to @list or @set, the compacted value is that
         # 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,24 +52,31 @@ 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
 
         # Look up term definintions from property using the original type-scoped context, if it exists, but apply them to the now current previous context
         td = input_context.term_definitions[property] if property
-        self.context = context.parse(td.context, override_protected: true) if td && td.context
+        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')
-          result = context.compact_value(property, element, log_depth: @options[:log_depth])
+          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
 
         # If expanded property is @list and we're contained within a list container, recursively compact this item to an array
-        if list?(element) && context.container(property) == CONTAINER_MAPPING_LIST
-          return compact(element['@list'], property: property, ordered: ordered)
+        if list?(element) && context.container(property).include?('@list')
+          return compact(element['@list'], base: base,
+                         property: property,
+                         log_depth: log_depth.to_i + 1)
         end
 
         inside_reverse = property == '@reverse'
@@ -85,15 +89,18 @@ module JSON::LD
           sort.
           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) if term_context
+          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: ordered).each do |expanded_property|
+        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 {|expanded_id| context.compact_iri(expanded_id)}
+            compacted_value = Array(expanded_value).map do |expanded_id|
+              context.compact_iri(expanded_id, base: @options[:base])
+            end
 
             kw_alias = context.compact_iri('@id', vocab: true)
             as_array = compacted_value.length > 1
@@ -103,21 +110,24 @@ module JSON::LD
           end
 
           if expanded_property == '@type'
-            compacted_value = Array(expanded_value).map {|expanded_type| input_context.compact_iri(expanded_type, vocab: true)}
+            compacted_value = Array(expanded_value).map do |expanded_type|
+              input_context.compact_iri(expanded_type, vocab: true)
+            end
 
             kw_alias = context.compact_iri('@type', vocab: true)
             as_array = compacted_value.length > 1 ||
                        (context.as_array?(kw_alias) &&
                         !value?(element) &&
                         context.processingMode('json-ld-1.1'))
-            compacted_value = compacted_value.first unless as_array
-            result[kw_alias] = compacted_value
+            add_value(result, kw_alias, compacted_value, property_is_array: as_array)
             next
           end
 
           if expanded_property == '@reverse'
-            compacted_value = compact(expanded_value, property: '@reverse', ordered: ordered)
-            #log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
+            compacted_value = compact(expanded_value, base: base,
+                                      property: '@reverse',
+                                      log_depth: log_depth.to_i + 1)
+            log_debug("@reverse", depth: log_depth.to_i) {"compacted_value: #{compacted_value.inspect}"}
             # handle double-reversed properties
             compacted_value.each do |prop, value|
               if context.reverse?(prop)
@@ -128,8 +138,8 @@ module JSON::LD
             end
 
             unless compacted_value.empty?
-              al = context.compact_iri('@reverse', quiet: true)
-              #log_debug("") {"remainder: #{al} => #{compacted_value.inspect}"}
+              al = context.compact_iri('@reverse')
+              log_debug("", depth: log_depth.to_i) {"remainder: #{al} => #{compacted_value.inspect}"}
               result[al] = compacted_value
             end
             next
@@ -137,8 +147,10 @@ module JSON::LD
 
           if expanded_property == '@preserve'
             # Compact using `property`
-            compacted_value = compact(expanded_value, property: property, ordered: ordered)
-            #log_debug("@preserve") {"compacted_value: #{compacted_value.inspect}"}
+            compacted_value = compact(expanded_value, base: base,
+                                      property: property,
+                                      log_depth: log_depth.to_i + 1)
+            log_debug("@preserve", depth: log_depth.to_i) {"compacted_value: #{compacted_value.inspect}"}
 
             unless compacted_value.is_a?(Array) && compacted_value.empty?
               result['@preserve'] = compacted_value
@@ -146,15 +158,15 @@ module JSON::LD
             next
           end
 
-          if expanded_property == '@index' && context.container(property) == CONTAINER_MAPPING_INDEX
-            #log_debug("@index") {"drop @index"}
+          if expanded_property == '@index' && context.container(property).include?('@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, quiet: true)
-            #log_debug(expanded_property) {"#{al} => #{expanded_value.inspect}"}
+            al = context.compact_iri(expanded_property, vocab: true)
+            log_debug(expanded_property, depth: log_depth.to_i) {"#{al} => #{expanded_value.inspect}"}
             result[al] = expanded_value
             next
           end
@@ -164,8 +176,7 @@ module JSON::LD
               context.compact_iri(expanded_property,
                                   value: expanded_value,
                                   vocab: true,
-                                  reverse: inside_reverse,
-                                  log_depth: @options[:log_depth])
+                                  reverse: inside_reverse)
 
             if nest_prop = context.nest(item_active_property)
               result[nest_prop] ||= {}
@@ -183,8 +194,7 @@ module JSON::LD
               context.compact_iri(expanded_property,
                                   value: expanded_item,
                                   vocab: true,
-                                  reverse: inside_reverse,
-                                  log_depth: @options[:log_depth])
+                                  reverse: inside_reverse)
 
 
             nest_result = if nest_prop = context.nest(item_active_property)
@@ -203,17 +213,19 @@ module JSON::LD
             else expanded_item
             end
 
-            compacted_item = compact(value, property: item_active_property, ordered: ordered)
-            #log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
+            compacted_item = compact(value, base: base,
+                                     property: item_active_property,
+                                     log_depth: log_depth.to_i + 1)
+            log_debug("", depth: log_depth.to_i) {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
 
             # handle @list
             if list?(expanded_item)
               compacted_item = as_array(compacted_item)
-              unless container == CONTAINER_MAPPING_LIST
-                al = context.compact_iri('@list', vocab: true, quiet: true)
+              unless container.include?('@list')
+                al = context.compact_iri('@list', vocab: true)
                 compacted_item = {al => compacted_item}
                 if expanded_item.has_key?('@index')
-                  key = context.compact_iri('@index', vocab: true, quiet: true)
+                  key = context.compact_iri('@index', vocab: true)
                   compacted_item[key] = expanded_item['@index']
                 end
               else
@@ -231,11 +243,11 @@ module JSON::LD
                 map_object = nest_result[item_active_property] ||= {}
                 # If there is no @id, create a blank node identifier to use as an index
                 map_key = if container.include?('@id') && expanded_item['@id']
-                  context.compact_iri(expanded_item['@id'], quiet: true)
+                  context.compact_iri(expanded_item['@id'], base: @options[:base])
                 elsif container.include?('@index') && expanded_item['@index']
-                  context.compact_iri(expanded_item['@index'], quiet: true)
+                  context.compact_iri(expanded_item['@index'], vocab: true)
                 else
-                  context.compact_iri('@none', vocab: true, quiet: true)
+                  context.compact_iri('@none', vocab: true)
                 end
                 add_value(map_object, map_key, compacted_item,
                   property_is_array: as_array)
@@ -243,7 +255,7 @@ module JSON::LD
                 # container includes @graph but not @id or @index and value is a simple graph object
                 if compacted_item.is_a?(Array) && compacted_item.length > 1
                   # Mutple objects in the same graph can't be represented directly, as they would be interpreted as two different graphs. Need to wrap in @included.
-                  included_key = context.compact_iri('@included', vocab: true).to_s
+                  included_key = context.compact_iri('@included', vocab: true)
                   compacted_item = {included_key => compacted_item}
                 end
                 # Drop through, where compacted_item will be added
@@ -251,35 +263,34 @@ module JSON::LD
                   property_is_array: as_array)
               else
                 # container does not include @graph or otherwise does not match one of the previous cases, redo compacted_item
-                al = context.compact_iri('@graph', vocab: true, quiet: true)
+                al = context.compact_iri('@graph', vocab: true)
                 compacted_item = {al => compacted_item}
                 if expanded_item['@id']
-                  al = context.compact_iri('@id', vocab: true, quiet: true)
-                  compacted_item[al] = context.compact_iri(expanded_item['@id'], vocab: false, quiet: true).to_s
+                  al = context.compact_iri('@id', vocab: true)
+                  compacted_item[al] = context.compact_iri(expanded_item['@id'], vocab: false)
                 end
                 if expanded_item.has_key?('@index')
-                  key = context.compact_iri('@index', vocab: true, quiet: true)
+                  key = context.compact_iri('@index', vocab: true)
                   compacted_item[key] = expanded_item['@index']
                 end
                 add_value(nest_result, item_active_property, compacted_item,
                   property_is_array: as_array)
               end
-            elsif container.any? { |key| CONTAINER_MAPPING_LANGUAGE_INDEX_ID_TYPE.include?(key) } && !container.include?('@graph')
+            elsif container.intersect?(CONTAINER_MAPPING_LANGUAGE_INDEX_ID_TYPE) && !container.include?('@graph')
               map_object = nest_result[item_active_property] ||= {}
               c = container.first
-              container_key = context.compact_iri(c, vocab: true, quiet: true)
-              compacted_item = case container
-              when CONTAINER_MAPPING_ID
+              container_key = context.compact_iri(c, vocab: true)
+              compacted_item = case
+              when container.include?('@id')
                 map_key = compacted_item[container_key]
                 compacted_item.delete(container_key)
                 compacted_item
-              when CONTAINER_MAPPING_INDEX
+              when container.include?('@index')
                 index_key = context.term_definitions[item_active_property].index || '@index'
                 if index_key == '@index'
                   map_key = expanded_item['@index']
-                  compacted_item.delete(container_key) if compacted_item.is_a?(Hash)
                 else
-                  container_key = context.compact_iri(index_key, vocab: true, quiet: true)
+                  container_key = context.compact_iri(index_key, vocab: true)
                   map_key, *others = Array(compacted_item[container_key])
                   if map_key.is_a?(String)
                     case others.length
@@ -288,15 +299,15 @@ module JSON::LD
                     else        compacted_item[container_key] = others
                     end
                   else
-                    map_key = context.compact_iri('@none', vocab: true, quiet: true)
+                    map_key = context.compact_iri('@none', vocab: true)
                   end
                 end
                 # Note, if compacted_item is a node reference and key is @id-valued, then this could be compacted further.
                 compacted_item
-              when CONTAINER_MAPPING_LANGUAGE
+              when container.include?('@language')
                 map_key = expanded_item['@language']
                 value?(expanded_item) ? expanded_item['@value'] : compacted_item
-              when CONTAINER_MAPPING_TYPE
+              when container.include?('@type')
                 map_key, *types = Array(compacted_item[container_key])
                 case types.length
                 when 0 then compacted_item.delete(container_key)
@@ -306,11 +317,14 @@ module JSON::LD
 
                 # if compacted_item contains a single entry who's key maps to @id, then recompact the item without @type
                 if compacted_item.keys.length == 1 && expanded_item.keys.include?('@id')
-                  compacted_item = compact({'@id' => expanded_item['@id']}, property: item_active_property)
+                  compacted_item = compact({'@id' => expanded_item['@id']},
+                                           base: base,
+                                           property: item_active_property,
+                                           log_depth: log_depth.to_i + 1)
                 end
                 compacted_item
               end
-              map_key ||= context.compact_iri('@none', vocab: true, quiet: true)
+              map_key ||= context.compact_iri('@none', vocab: true)
               add_value(map_object, map_key, compacted_item,
                 property_is_array: as_array)
             else
@@ -323,7 +337,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