json-ld 3.1.2 → 3.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80dcb6be296036b1a18ead88bd014259a415329b127f326479239c15aa4d634c
-  data.tar.gz: d0b0faa2cf53cca55f62e8a5e149016654796ab726f709ae66a9a4f6aa1b336b
+  metadata.gz: a9799c8872d44570fe8213d9f9f54067ced632dcbfc593cb84f4223889f2530d
+  data.tar.gz: 9854ae82f3e53cb08ce4e5c8f8223d8def8c3bf86cac7ab95a6abbf08a448003
 SHA512:
-  metadata.gz: 29916449e8674ad3df3a8b1a9dd81128e565e40f37c276174f1584113a7933659de51c30d56b9f73e6487f20a711f2bbc1c034d54f64ae6677285a0609513a31
-  data.tar.gz: 85dea41c304414e584e6b343f3230e41d88d70e18213a6b916971c76d0be9f7b628bfe7bee022605c0c18d8cdec3b3e102cb6883c128946dbf2f84c8a901e77e
+  metadata.gz: 4fb50a75c8d031026e97635ad5305d9318d455af2786b84e5ca42d0f0546ba1f1175dd5dbc05a884798145051aa352a8f1688fdb6a5ad593d057d3900d9c6f21
+  data.tar.gz: a844a733d4f292988638dc2da6be301a78d3294b3a64533398effb0b41b802bf7f48834d5e2754d3d65a6f2f69b802bcfc0ecbc44a159fdf2389ea16ae49bbad

data/VERSION

@@ -1 +1 @@
-3.1.2
+3.1.3

data/lib/json/ld/context.rb

@@ -21,6 +21,11 @@ module JSON::LD
     # @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.
@@ -121,7 +126,7 @@ module JSON::LD
                     direction_mapping: nil,
                     reverse_property: false,
                     nest: nil,
-                    protected: false,
+                    protected: nil,
                     simple: false,
                     prefix: nil,
                     context: nil)
@@ -331,8 +336,18 @@ module JSON::LD
     # @raise [JsonLdError]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
     # @return [Context]
-    def self.parse(local_context, protected: false, override_protected: false, propagate: true, **options)
-      self.new(**options).parse(local_context, protected: false, override_protected: override_protected, propagate: propagate)
+    def self.parse(local_context, override_protected: false, propagate: true, **options)
+      self.new(**options).parse(local_context, 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
 
     ##
@@ -522,7 +537,6 @@ module JSON::LD
     #
     # @param [String, #read, Array, Hash, Context] local_context
     # @param [Array<String>] remote_contexts
-    # @param [Boolean] protected Make defined terms protected (as if `@protected` were used).
     # @param [Boolean] override_protected Protected terms may be cleared.
     # @param [Boolean] propagate
     #   If false, retains any previously defined term, which can be rolled back when the descending into a new node object changes.
@@ -535,7 +549,6 @@ module JSON::LD
     # @see https://www.w3.org/TR/json-ld11-api/index.html#context-processing-algorithm
     def parse(local_context,
               remote_contexts: [],
-              protected: false,
               override_protected: false,
               propagate: true,
               validate_scoped: true)
@@ -561,7 +574,7 @@ module JSON::LD
           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 +583,6 @@ module JSON::LD
             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,7 +594,7 @@ module JSON::LD
           # 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)
@@ -590,11 +602,7 @@ module JSON::LD
           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 +611,10 @@ module JSON::LD
               #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 +623,29 @@ module JSON::LD
               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 = ctx.parse(remote_doc.document['@context'], remote_contexts: remote_contexts.dup)
+                ctx.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}"}
-              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
-
-            # 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
           end
-          context.base ||= result.base
+
+          # Merge loaded context noting protected term overriding
+          context = result.merge(cached_context, override_protected: override_protected)
+
+          context.previous_context = self unless propagate
           result = context
           #log_debug("parse") {"=> provided_context: #{context.inspect}"}
         when Hash
@@ -665,10 +673,12 @@ module JSON::LD
                   requestProfile: 'http://www.w3.org/ns/json-ld#context',
                   base: nil)
                 context_opts.delete(:headers)
+                # FIXME: should cache this, but ContextCache is for parsed contexts
                 JSON::LD::API.loadRemoteDocument(source, **context_opts) do |remote_doc|
                   # Dereference source. 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, "#{source}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.has_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')
                   context.delete(key)
@@ -682,7 +692,7 @@ module JSON::LD
                 raise JsonLdError::LoadingRemoteContextFailed, "#{source}: #{e.message}", e.backtrace
               end
             else
-              result.send(setter, context[key], remote_contexts: remote_contexts, protected: context.fetch('@protected', protected))
+              result.send(setter, context[key], remote_contexts: remote_contexts)
             end
             context.delete(key)
           end
@@ -694,7 +704,7 @@ module JSON::LD
             # ... where key is not @base, @vocab, @language, or @version
             result.create_term_definition(context, key, defined,
                                           override_protected: override_protected,
-                                          protected: context.fetch('@protected', protected),
+                                          protected: context['@protected'],
                                           remote_contexts: remote_contexts.dup,
                                           validate_scoped: validate_scoped
                                           ) unless NON_TERMDEF_KEYS.include?(key)
@@ -711,28 +721,32 @@ module JSON::LD
     # 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 = Context.new(term_definitions: self.term_definitions.dup(), standard_prefixes: options[:standard_prefixes])
+      ctx.context_base = context.context_base || self.context_base
+      ctx.default_language = context.default_language || self.default_language
+      ctx.default_direction = context.default_direction || self.default_direction
+      ctx.vocab = context.vocab || self.vocab
+      ctx.base = context.base || self.base
+      ctx.provided_context = self.provided_context
+      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
@@ -768,7 +782,7 @@ module JSON::LD
     # @see https://www.w3.org/TR/json-ld11-api/index.html#create-term-definition
     def create_term_definition(local_context, term, defined,
         override_protected: false,
-        protected: false,
+        protected: nil,
         remote_contexts: [],
         validate_scoped: true)
       # Expand a string value, unless it matches a keyword
@@ -985,9 +999,16 @@ module JSON::LD
 
       if value.has_key?('@context')
         begin
-          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 = value['@context'] ? value['@context'] : [nil]
+          definition.context = case value['@context']
+          when String then new_ctx.context_base
+          when nil then [nil]
+          else value['@context']
+          end
         rescue JsonLdError => e
           raise JsonLdError::InvalidScopedContext, "Term definition for #{term.inspect} contains illegal value for @context: #{e.message}"
         end
@@ -1832,8 +1853,11 @@ module JSON::LD
       that = self
       ec = super
       ec.instance_eval do
-        @term_definitions = that.term_definitions.dup
+        @term_definitions = that.term_definitions.inject({}) do |memo, (term, defn)|
+          memo.merge(term => defn.dup())
+        end
         @iri_to_term = that.iri_to_term.dup
+        @inverse_context = nil
       end
       ec
     end

data/lib/json/ld/expand.rb

@@ -29,7 +29,7 @@ module JSON::LD
     #   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 @@ module JSON::LD
         # 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 @@ module JSON::LD
                       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 @@ module JSON::LD
         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 @@ module JSON::LD
         context.expand_value(active_property, input, log_depth: @options[:log_depth])
       end
 
-      #log_debug {" => #{result.inspect}"}
+      log_debug {" => #{result.inspect}"}
       result
     end
 

data/spec/compact_spec.rb

@@ -564,6 +564,7 @@ describe JSON::LD::API do
           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"
         })

data/spec/context_spec.rb

@@ -57,14 +57,14 @@ describe JSON::LD::Context do
     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 @@ describe JSON::LD::Context do
             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 @@ describe JSON::LD::Context do
             ),
             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 @@ describe JSON::LD::Context do
       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 @@ describe JSON::LD::Context do
 
       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 @@ describe JSON::LD::Context do
           )
           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 @@ describe JSON::LD::Context do
       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 @@ describe JSON::LD::Context do
       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 @@ describe JSON::LD::Context do
     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")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.1.3
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-18 00:00:00.000000000 Z
+date: 2020-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf