Don't overload context PRELOADED with local cache.

Parse contexts without scope, and merge into active context.
Improve context merging to look for term protection overrides.

Author: gkellogg

lib/json/ld/context.rb

@@ -21,6 +21,11 @@ class Context
     # @return [Hash{Symbol => Context}]
     PRELOADED = {}
 
+    ##
+    # Defines the maximum number of interned URI references that can be held
+    # cached in memory at any one time.
+    CACHE_SIZE = -1 # unlimited by default
+
     class << self
       ##
       # Add preloaded context. In the block form, the context is lazy evaulated on first use.
@@ -335,6 +340,16 @@ def self.parse(local_context, protected: false, override_protected: false, propa
       self.new(**options).parse(local_context, protected: false, override_protected: override_protected, propagate: propagate)
     end
 
+    ##
+    # Class-level cache used for retaining parsed remote contexts.
+    #
+    # @return [RDF::Util::Cache]
+    # @private
+    def self.cache
+      require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
+      @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
+    end
+
     ##
     # Create new evaluation context
     # @param [Hash] options
@@ -561,7 +576,7 @@ def parse(local_context,
           end
         when Context
            #log_debug("parse") {"context: #{context.inspect}"}
-           result = context.dup
+           result = result.merge(context)
         when IO, StringIO
           #log_debug("parse") {"io: #{context}"}
           # Load context document, if it is an open file
@@ -570,7 +585,6 @@ def parse(local_context,
             raise JSON::LD::JsonLdError::InvalidRemoteContext, "Context missing @context key" if @options[:validate] && ctx['@context'].nil?
             result = result.dup.parse(ctx["@context"] ? ctx["@context"].dup : {})
             result.provided_context = ctx["@context"] if [context] == local_context
-            result
           rescue JSON::ParserError => e
             #log_debug("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]
@@ -582,19 +596,15 @@ def parse(local_context,
           # 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 || options[:base]).join(context)
           context_canon = context.canonicalize
-          context_canon.scheme == 'http' if context_canon.scheme == 'https'
+          context_canon.scheme = 'http' if context_canon.scheme == 'https'
 
           # If validating a scoped context which has already been loaded, skip to the next one
           next if !validate_scoped && remote_contexts.include?(context.to_s)
 
           remote_contexts << context.to_s
           raise JsonLdError::ContextOverflow, "#{context}" if remote_contexts.length >= MAX_CONTEXTS_LOADED
 
-          context_no_base = result.dup
-          context_no_base.base = nil
-          context_no_base.context_base = context.to_s
-
-          if PRELOADED[context_canon.to_s]
+          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}"}
 
@@ -603,10 +613,10 @@ def parse(local_context,
               #log_debug("parse") {"=> (call)"}
               PRELOADED[context_canon.to_s] = PRELOADED[context_canon.to_s].call
             end
-            context = context_no_base.merge!(PRELOADED[context_canon.to_s])
+            PRELOADED[context_canon.to_s]
           else
             # Load context document, if it is a string
-            begin
+            Context.cache[context_canon.to_s] ||= begin
               context_opts = @options.merge(
                 profile: 'http://www.w3.org/ns/json-ld#context',
                 requestProfile: 'http://www.w3.org/ns/json-ld#context',
@@ -615,29 +625,33 @@ def parse(local_context,
               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')
-                context = remote_doc.document['@context']
+
+                # Parse stand-alone
+                ctx = Context.new(**options)
+                ctx.context_base = context.to_s
+                ctx.parse(remote_doc.document['@context'], remote_contexts: remote_contexts.dup)
               end
             rescue JsonLdError::LoadingDocumentFailed => e
               #log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
-              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}: #{e.message}", e.backtrace
+              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}"}
-              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}: #{e.message}", e.backtrace
+              raise JsonLdError::LoadingRemoteContextFailed, "#{context}: #{e.message}", e.backtrace
             end
+          end.dup()
 
-            # 3.2.6) Set context to the result of recursively calling this algorithm, passing context no base for active context, context for local context, and remote contexts.
-            context = context_no_base.parse(context,
-                remote_contexts: remote_contexts.dup,
-                protected: protected,
-                override_protected: override_protected,
-                propagate: propagate,
-                validate_scoped: validate_scoped)
-            PRELOADED[context_canon.to_s] = context.dup
-            context.provided_context = result.provided_context
+          # if `protected` is true, update term definitions to be protected
+          # FIXME: if they were explicitly marked not protected, then this will fail
+          if protected
+            cached_context.term_definitions.each {|td| td.protected = true}
           end
-          context.base ||= result.base
+
+          # Merge loaded context noting protected term overriding
+          context = result.merge(cached_context, override_protected: override_protected)
+
+          context.previous_context = result unless propagate
           result = context
           #log_debug("parse") {"=> provided_context: #{context.inspect}"}
         when Hash
@@ -711,28 +725,31 @@ def parse(local_context,
     # Merge in a context, creating a new context with updates from `context`
     #
     # @param [Context] context
+    # @param [Boolean] protected mark resulting context as protected
+    # @param [Boolean] override_protected Allow or disallow protected terms to be changed
+    # @param [Boolean]
     # @return [Context]
-    def merge(context)
-      c = self.dup.merge!(context)
-      c.instance_variable_set(:@term_definitions, context.term_definitions.dup)
-      c
-    end
+    def merge(context, override_protected: false)
+      ctx = self.dup
+      ctx.context_base = context.context_base if context.context_base
+      ctx.default_language = context.default_language if context.default_language
+      ctx.default_direction = context.default_direction if context.default_direction
+      ctx.vocab = context.vocab if context.vocab
+      ctx.base = context.base if context.base
+      if !override_protected
+        ctx.term_definitions.each do |term, definition|
+          next unless definition.protected? && (other = context.term_definitions[term])
+          unless definition == other
+            raise JSON::LD::JsonLdError::ProtectedTermRedefinition, "Attempt to redefine protected term #{term}"
+          end
+        end
+      end
 
-    ##
-    # Update context with definitions from `context`
-    #
-    # @param [Context] context
-    # @return [self]
-    def merge!(context)
-      # FIXME: if new context removes the default language, this won't do anything
-      self.default_language = context.default_language if context.default_language
-      self.vocab = context.vocab if context.vocab
-      self.base = context.base if context.base
-
-      # Merge in Term Definitions
-      term_definitions.merge!(context.term_definitions)
-      @inverse_context = nil  # Re-build after term definitions set
-      self
+      # Add term definitions
+      context.term_definitions.each do |term, definition|
+        ctx.term_definitions[term] = definition
+      end
+      ctx
     end
 
     # The following constants are used to reduce object allocations in #create_term_definition below
@@ -985,7 +1002,10 @@ def create_term_definition(local_context, term, defined,
 
       if value.has_key?('@context')
         begin
-          new_ctx = self.parse(value['@context'], override_protected: true, remote_contexts: remote_contexts, validate_scoped: false)
+          new_ctx = self.parse(value['@context'],
+                               override_protected: true,
+                               remote_contexts: remote_contexts,
+                               validate_scoped: false)
           # Record null context in array form
           definition.context = case value['@context']
           when String then new_ctx.context_base
@@ -1838,6 +1858,7 @@ def dup
       ec.instance_eval do
         @term_definitions = that.term_definitions.dup
         @iri_to_term = that.iri_to_term.dup
+        @inverse_context = nil
       end
       ec
     end

lib/json/ld/expand.rb

@@ -29,7 +29,7 @@ module Expand
     #   Expanding from a map, which could be an `@type` map, so don't clear out context term definitions
     # @return [Array<Hash{String => Object}>]
     def expand(input, active_property, context, ordered: false, framing: false, from_map: false)
-      #log_debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
+      log_debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       framing = false if active_property == '@default'
       expanded_active_property = context.expand_iri(active_property, vocab: true, as_string: true) if active_property
 
@@ -73,7 +73,7 @@ def expand(input, active_property, context, ordered: false, framing: false, from
         # 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')
           context = context.parse(input.delete('@context'))
-          #log_debug("expand") {"context: #{context.inspect}"}
+          log_debug("expand") {"context: #{context.inspect}"}
         end
 
         # Set the type-scoped context to the context on input, for use later
@@ -102,7 +102,7 @@ def expand(input, active_property, context, ordered: false, framing: false, from
                       ordered: ordered,
                       framing: framing)
 
-        #log_debug("output object") {output_object.inspect}
+        log_debug("output object") {output_object.inspect}
 
         # If result contains the key @value:
         if value?(output_object)
@@ -161,7 +161,7 @@ def expand(input, active_property, context, ordered: false, framing: false, from
         if (expanded_active_property || '@graph') == '@graph' &&
            (output_object.key?('@value') || output_object.key?('@list') ||
            (output_object.keys - KEY_ID).empty? && !framing)
-          #log_debug(" =>") { "empty top-level: " + output_object.inspect}
+          log_debug(" =>") { "empty top-level: " + output_object.inspect}
           return nil
         end
 
@@ -181,7 +181,7 @@ def expand(input, active_property, context, ordered: false, framing: false, from
         context.expand_value(active_property, input, log_depth: @options[:log_depth])
       end
 
-      #log_debug {" => #{result.inspect}"}
+      log_debug {" => #{result.inspect}"}
       result
     end
 

spec/compact_spec.rb

@@ -564,6 +564,7 @@
           documentUrl: "http://example.com/context")
       end
       it "uses referenced context" do
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         input = ::JSON.parse %({
           "http://example.com/b": "c"
         })

spec/context_spec.rb

@@ -57,14 +57,14 @@ def containers
     context "remote" do
 
       it "retrieves and parses a remote context document" do
-        JSON::LD::Context::PRELOADED.clear
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
         ec = subject.parse("http://example.com/context")
         expect(ec.provided_context).to produce("http://example.com/context", logger)
       end
 
       it "fails given a missing remote @context" do
-        JSON::LD::Context::PRELOADED.clear
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_raise(IOError)
         expect {subject.parse("http://example.com/context")}.to raise_error(JSON::LD::JsonLdError::LoadingRemoteContextFailed, %r{http://example.com/context})
       end
@@ -116,7 +116,7 @@ def containers
             documentUrl: "http://example.com/context",
             contentType: "text/html")
 
-        JSON::LD::Context::PRELOADED.clear
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
         ec = subject.parse("http://example.com/context")
         expect(ec.send(:mappings)).to produce({
@@ -154,7 +154,7 @@ def containers
             ),
             documentUrl: "http://example.com/context",
             contentType: "text/html")
-          JSON::LD::Context::PRELOADED.clear
+          JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
         ec = subject.parse("http://example.com/context")
         expect(ec.send(:mappings)).to produce({
@@ -170,7 +170,7 @@ def containers
       end
 
       it "parses a referenced context at a relative URI" do
-        JSON::LD::Context::PRELOADED.clear
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         rd1 = JSON::LD::API::RemoteDocument.new(%({"@context": "context"}), base_uri: "http://example.com/c1")
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/c1", anything).and_yield(rd1)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
@@ -185,7 +185,7 @@ def containers
 
       context "remote with local mappings" do
         let(:ctx) {["http://example.com/context", {"integer" => "xsd:integer"}]}
-        before {JSON::LD::Context::PRELOADED.clear}
+        before {JSON::LD::Context.instance_variable_set(:@cache, nil)}
         it "retrieves and parses a remote context document" do
           expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
           subject.parse(ctx)
@@ -206,7 +206,7 @@ def containers
           )
           JSON::LD::Context.alias_preloaded("https://example.com/preloaded", "http://example.com/preloaded")
         }
-        after(:all) {JSON::LD::Context::PRELOADED.clear}
+        after(:all) {JSON::LD::Context.instance_variable_set(:@cache, nil)}
 
         it "does not load referenced context" do
           expect(JSON::LD::API).not_to receive(:documentLoader).with(ctx, anything)
@@ -249,6 +249,7 @@ def containers
       end
 
       it "merges definitions from remote contexts" do
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
         rd2 = JSON::LD::API::RemoteDocument.new(%q({
           "@context": {
@@ -476,7 +477,7 @@ def containers
       end
 
       context "@import" do
-        before(:each) {JSON::LD::Context::PRELOADED.clear}
+        before(:each) {JSON::LD::Context.instance_variable_set(:@cache, nil)}
         it "generates an InvalidImportValue error if not a string" do
           expect {subject.parse({'@version' => 1.1, '@import' => true})}.to raise_error(JSON::LD::JsonLdError::InvalidImportValue)
         end
@@ -642,18 +643,8 @@ def containers
     end
   end
 
-  describe "#merge!" do
-    it "updates context with components from new" do
-      c2 = JSON::LD::Context.parse({'foo' => "http://example.com/"})
-      cm = context.merge!(c2)
-      expect(cm).to equal context
-      expect(cm).not_to equal c2
-      expect(cm.term_definitions).to eq c2.term_definitions
-    end
-  end
-
   describe "#serialize" do
-    before {JSON::LD::Context::PRELOADED.clear}
+    before {JSON::LD::Context.instance_variable_set(:@cache, nil)}
     it "context document" do
       expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
       ec = subject.parse("http://example.com/context")