Implement compactToRelative by controlling if compacting context uses the document base as _base IRI_.

Author: gkellogg

example-files/issue-507.rb

@@ -0,0 +1,27 @@
+require 'pp'
+require 'linkeddata'
+
+context = JSON.parse %({
+  "@context": {
+    "id": "@id",
+    "rdfs": {"@id": "http://.../"},
+    "seeAlso": {"@id": "rdfs:seeAlso", "@container": "@set"}
+  }
+})
+
+input = JSON.parse %({
+  "@context": {
+    "id": "@id",
+    "rdfs": {"@id": "http://.../"},
+    "seeAlso": {"@id": "rdfs:seeAlso", "@container": "@set"}
+  },
+  "seeAlso": [
+    {
+      "id": "http://example.org/reference1"
+    },
+    "http://example.org/reference2",
+    {"id": "http://example.org/reference3", "format": "text/html"}
+  ]
+})
+
+pp JSON::LD::API.compact(input, context['@context'])

lib/json/ld/api.rb

@@ -90,13 +90,12 @@ def initialize(input, context, options = {}, &block)
       @options = {
         compactArrays:      true,
         rename_bnodes:      true,
-        documentLoader:     self.class.method(:documentLoader),
-        compactToRelative:  true
+        documentLoader:     self.class.method(:documentLoader)
       }.merge(options)
       @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
       # For context via Link header
-      context_ref = nil
+      remote_base, context_ref = nil, nil
 
       @value = case input
       when Array, Hash then input.dup
@@ -116,8 +115,9 @@ def initialize(input, context, options = {}, &block)
       when String
         remote_doc = @options[:documentLoader].call(input, @options)
 
-        @options = {base: remote_doc.documentUrl}.merge(@options)
+        remote_base = remote_doc.documentUrl
         context_ref = remote_doc.contextUrl
+        @options = {base: remote_doc.documentUrl}.merge(@options) unless @options[:no_default_base]
 
         case remote_doc.document
         when String
@@ -136,13 +136,6 @@ def initialize(input, context, options = {}, &block)
       @options[:processingMode] ||= @context.processingMode || "json-ld-1.0"
       @options[:validate] ||= %w(json-ld-1.0 json-ld-1.1).include?(@options[:processingMode])
 
-      # If, after processing, the context does not have a _base IRI_, and the _compactToRelative_ option is set to true or processingMode is json-ld-1.0, set _base IRI_ in the active context to either the _base_ option from the API, if set, or the IRI of the currently being processed document.
-      if !@context.base && @options[:base]
-        doc_base = RDF::URI(@options[:base]).dup
-        doc_base.canonicalize! if options[:canonicalize]
-        @context.base = doc_base
-      end
-
       if block_given?
         case block.arity
           when 0, -1 then instance_eval(&block)
@@ -222,16 +215,17 @@ def self.expand(input, options = {}, &block)
     # @see http://json-ld.org/spec/latest/json-ld-api/#compaction-algorithm
     def self.compact(input, context, options = {})
       result = nil
+      options = {compactToRelative:  true}.merge(options)
 
       # 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 = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
-        options[:base] ||= base_iri
+        options[:base] ||= base_iri if options[:compactToRelative]
         result
       end
 
       #require 'byebug'; byebug
-      API.new(expanded_input, context, options) do
+      API.new(expanded_input, context, options.merge(no_default_base: true)) do
         log_debug(".compact") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = compact(value)
 
@@ -267,15 +261,16 @@ def self.compact(input, context, options = {})
     # @see http://json-ld.org/spec/latest/json-ld-api/#framing-algorithm
     def self.flatten(input, context, options = {})
       flattened = []
+      options = {compactToRelative:  true}.merge(options)
 
       # Expand input to simplify processing
       expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
-        options[:base] ||= base_iri
+        options[:base] ||= base_iri if options[:compactToRelative]
         result
       end
 
       # Initialize input using
-      API.new(expanded_input, context, options) do
+      API.new(expanded_input, context, options.merge(no_default_base: true)) do
         log_debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
@@ -340,6 +335,7 @@ def self.frame(input, frame, options = {})
       options = {
         base:                       (input if input.is_a?(String)),
         compactArrays:              true,
+        compactToRelative:          true,
         embed:                      '@last',
         explicit:                   false,
         requireAll:                 true,
@@ -369,15 +365,15 @@ def self.frame(input, frame, options = {})
 
       # Expand input to simplify processing
       expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
-        options[:base] ||= base_iri
+        options[:base] ||= base_iri if options[:compactToRelative]
         result
       end
 
       # Expand frame to simplify processing
       expanded_frame = API.expand(frame, options.merge(processingMode: "json-ld-1.1-expand-frame"))
 
       # Initialize input using frame as context
-      API.new(expanded_input, nil, options) do
+      API.new(expanded_input, nil, options.merge(no_default_base: true)) do
         log_debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary

lib/json/ld/context.rb

@@ -1187,10 +1187,7 @@ def compact_iri(iri, value: nil, vocab: nil, reverse: false, quiet: false, **opt
         candidates << ciri unless value && term_definitions.has_key?(ciri)
       end if candidates.empty?
 
-      if !candidates.empty?
-        #log_debug("") {"=> compact iri: #{candidates.term_sort.first.inspect}"} unless quiet
-        return candidates.term_sort.first
-      end
+      return candidates.term_sort.first if !candidates.empty?
 
       # If we still don't have any terms and we're using standard_prefixes,
       # try those, and add to mapping
@@ -1203,13 +1200,10 @@ def compact_iri(iri, value: nil, vocab: nil, reverse: false, quiet: false, **opt
             iri.sub(v.to_uri.to_s, "#{prefix}:").sub(/:$/, '')
           end
 
-        if !candidates.empty?
-          #log_debug("") {"=> standard prefies: #{candidates.term_sort.first.inspect}"} unless quiet
-          return candidates.term_sort.first
-        end
+        return candidates.term_sort.first if !candidates.empty?
       end
 
-      if !vocab && @options[:compactToRelative]
+      if !vocab
         # transform iri to a relative IRI using the document's base IRI
         iri = remove_base(iri)
         #log_debug("") {"=> relative iri: #{iri.inspect}"} unless quiet