Keep document base out of context, and pass in through other algorithms. This allows for improved caching of initial contexts.

Author: gkellogg

Gemfile

@@ -34,7 +34,7 @@ group :development do
   gem 'sxp',                git: "https://github.com/dryruby/sxp.rb",               branch: "develop"
   gem 'fasterer'
   gem 'earl-report'
-  gem 'ruby-prof'
+  gem 'ruby-prof',  platforms: :mri
 end
 
 group :development, :test do

lib/json/ld/api.rb

@@ -130,7 +130,7 @@ def initialize(input, context, rename_bnodes: true, unique_bnodes: false, **opti
 
       # 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,9 +163,10 @@ def initialize(input, context, rename_bnodes: true, unique_bnodes: false, **opti
     #   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,
+          base: (RDF::URI(@options[:base]) if @options[:base]),
           ordered: @options[:ordered],
           framing: framing)
         doc_base = @options[:base]
@@ -224,15 +225,17 @@ def self.compact(input, context, expanded: false, **options)
 
       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,
+                         base: (RDF::URI(@options[:base]) if @options[:base]),
+                         ordered: options[:ordered])
 
         # 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)
           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
@@ -294,9 +297,14 @@ def self.flatten(input, context, expanded: false, **options)
 
         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]))
+          compacted = as_array(
+            compact(flattened,
+                    base: (RDF::URI(options[:base]) if options[:base]),
+                    ordered: options[:ordered]))
           kwgraph = self.context.compact_iri('@graph')
-          flattened = self.context.serialize.merge(kwgraph => compacted)
+          flattened = self.context.
+            serialize(provided_context: context).
+            merge(kwgraph => compacted)
         end
       end
 
@@ -335,7 +343,7 @@ def self.flatten(input, context, expanded: false, **options)
     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',
@@ -426,19 +434,24 @@ def self.frame(input, frame, expanded: false, **options)
         log_debug(".frame") {"expanded result: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Compact result
-        compacted = compact(result, ordered: @options[:ordered])
+        compacted = compact(result,
+          base: (RDF::URI(options[:base]) if options[:base]),
+          ordered: options[:ordered])
 
         # @replace `@null` with nil, compacting arrays
         compacted = cleanup_null(compacted)
         compacted = [compacted] unless options[:omitGraph] || compacted.is_a?(Array)
 
         # Add the given context to the output
         result = if !compacted.is_a?(Array)
-          context.serialize.merge(compacted)
+          compacted
         else
           kwgraph = context.compact_iri('@graph')
-          context.serialize.merge({kwgraph => compacted})
+          {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
@@ -520,9 +533,10 @@ def self.fromRdf(input, useRdfType: false, useNativeTypes: false, **options, &bl
 
       API.new(nil, nil, **options) do
         result = from_statements(input,
+          base: (RDF::URI(options[:base]) if options[:base]),
+          ordered: @options[:ordered],
           useRdfType: useRdfType,
-          useNativeTypes: useNativeTypes,
-          ordered: @options[:ordered])
+          useNativeTypes: useNativeTypes)
       end
 
       block_given? ? yield(result) : result
@@ -532,16 +546,18 @@ def self.fromRdf(input, useRdfType: false, useNativeTypes: false, **options, &bl
     # 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` 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 +566,14 @@ def self.fromRdf(input, useRdfType: false, useNativeTypes: false, **options, &bl
     #   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

lib/json/ld/compact.rb

@@ -12,11 +12,16 @@ module Compact
     # 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 [Boolean] ordered (true)
+    # @param [String] property (nil)
+    #   Extra validatation
     # @return [Array, Hash]
-    def compact(element, property: nil, ordered: false)
+    def compact(element,
+                base: nil,
+                ordered: false,
+                property: nil)
       #if property.nil?
       #  log_debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
       #else
@@ -29,7 +34,9 @@ def compact(element, property: nil, ordered: false)
       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, ordered: ordered, property: property)
+        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
@@ -55,10 +62,13 @@ def compact(element, property: nil, ordered: false)
 
         # 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)
+        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: base)
           if !result.is_a?(Hash) || context.coerce(property) == '@json'
             #log_debug("") {"=> scalar result: #{result.inspect}"}
             return result
@@ -67,7 +77,8 @@ def compact(element, property: nil, ordered: false)
 
         # If expanded property is @list and we're contained within a list container, recursively compact this item to an array
         if list?(element) && context.container(property).include?('@list')
-          return compact(element['@list'], property: property, ordered: ordered)
+          return compact(element['@list'], base: base,
+                         ordered: ordered, property: property)
         end
 
         inside_reverse = property == '@reverse'
@@ -80,15 +91,17 @@ def compact(element, property: nil, ordered: false)
           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?
         end
 
         element.keys.opt_sort(ordered: ordered).each do |expanded_property|
           expanded_value = element[expanded_property]
           #log_debug("") {"#{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: base)
+            end
 
             kw_alias = context.compact_iri('@id', vocab: true)
             as_array = compacted_value.length > 1
@@ -98,7 +111,9 @@ def compact(element, property: nil, ordered: false)
           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 ||
@@ -110,7 +125,8 @@ def compact(element, property: nil, ordered: false)
           end
 
           if expanded_property == '@reverse'
-            compacted_value = compact(expanded_value, property: '@reverse', ordered: ordered)
+            compacted_value = compact(expanded_value, base: base,
+                                      ordered: ordered, property: '@reverse')
             #log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
             # handle double-reversed properties
             compacted_value.each do |prop, value|
@@ -131,7 +147,8 @@ def compact(element, property: nil, ordered: false)
 
           if expanded_property == '@preserve'
             # Compact using `property`
-            compacted_value = compact(expanded_value, property: property, ordered: ordered)
+            compacted_value = compact(expanded_value, base: base,
+                                      ordered: ordered, property: property)
             #log_debug("@preserve") {"compacted_value: #{compacted_value.inspect}"}
 
             unless compacted_value.is_a?(Array) && compacted_value.empty?
@@ -158,8 +175,7 @@ def compact(element, property: nil, ordered: false)
               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] ||= {}
@@ -177,8 +193,7 @@ def compact(element, property: nil, ordered: false)
               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)
@@ -197,7 +212,8 @@ def compact(element, property: nil, ordered: false)
             else expanded_item
             end
 
-            compacted_item = compact(value, property: item_active_property, ordered: ordered)
+            compacted_item = compact(value, base: base,
+                                     ordered: ordered, property: item_active_property)
             #log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
 
             # handle @list
@@ -225,9 +241,9 @@ def compact(element, property: nil, ordered: false)
                 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'])
+                  context.compact_iri(expanded_item['@id'], base: base)
                 elsif container.include?('@index') && expanded_item['@index']
-                  context.compact_iri(expanded_item['@index'])
+                  context.compact_iri(expanded_item['@index'], vocab: true)
                 else
                   context.compact_iri('@none', vocab: true)
                 end
@@ -299,7 +315,10 @@ def compact(element, property: nil, ordered: false)
 
                 # 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,
+                                           ordered: ordered,
+                                           property: item_active_property)
                 end
                 compacted_item
               end