Add processingMode and @version anouncement requirement from json-ld/json-ld.org#446.

Author: gkellogg

lib/json/ld.rb

@@ -60,6 +60,7 @@ module LD
       @set
       @type
       @value
+      @version
       @vocab
     ).freeze
 
@@ -105,6 +106,7 @@ class InvalidContainerMapping < JsonLdError; @code = "invalid container mapping"
       class InvalidDefaultLanguage < JsonLdError; @code = "invalid default language"; end
       class InvalidIdValue < JsonLdError; @code = "invalid @id value"; end
       class InvalidIndexValue < JsonLdError; @code = "invalid @index value"; end
+      class InvalidVersionValue < JsonLdError; @code = "invalid @version value"; end
       class InvalidIRIMapping < JsonLdError; @code = "invalid IRI mapping"; end
       class InvalidKeywordAlias < JsonLdError; @code = "invalid keyword alias"; end
       class InvalidLanguageMapping < JsonLdError; @code = "invalid language mapping"; end
@@ -132,6 +134,7 @@ class ListOfLists < JsonLdError; @code = "list of lists"; end
       class LoadingDocumentFailed < JsonLdError; @code = "loading document failed"; end
       class LoadingRemoteContextFailed < JsonLdError; @code = "loading remote context failed"; end
       class MultipleContextLinkHeaders < JsonLdError; @code = "multiple context link headers"; end
+      class ProcessingModeConflict < JsonLdError; @code = "processing mode conflict"; end
       class RecursiveContextInclusion < JsonLdError; @code = "recursive context inclusion"; end
       class InvalidFrame < JsonLdError
         class MultipleEmbeds < InvalidFrame; end

lib/json/ld/api.rb

@@ -69,10 +69,12 @@ class API
     #   A context that is used to initialize the active context when expanding a document.
     # @option options [Boolean, String, RDF::URI] :flatten
     #   If set to a value that is not `false`, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of `flatten must` be either an _IRI_ value representing the name of the graph to flatten, or `true`. If the value is `true`, then the first graph encountered in the input document is selected and flattened.
-    # @option options [String] :processingMode ("json-ld-1.1")
+    # @option options [String] :processingMode
     #   Processing mode, json-ld-1.0 or json-ld-1.1. Also can have other values:
     #
     #   * json-ld-1.1-expand-frame – special frame expansion mode.
+    #
+    #   If `processingMode` is not specified, a mode of `json-ld-1.0` or `json-ld-1.1` is set, the context used for `expansion` or `compaction`.
     # @option options [Boolean] :rename_bnodes (true)
     #   Rename bnodes as part of expansion, or keep them the same.
     # @option options [Boolean]  :unique_bnodes   (false)
@@ -88,10 +90,8 @@ def initialize(input, context, options = {}, &block)
       @options = {
         compactArrays: true,
         rename_bnodes: true,
-        processingMode: "json-ld-1.1",
         documentLoader: self.class.method(:documentLoader)
       }
-      @options[:validate] = %w(json-ld-1.0 json-ld-1.1).include?(@options[:processingMode])
       @options = @options.merge(options)
       @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
@@ -135,6 +135,10 @@ def initialize(input, context, options = {}, &block)
       context ||= (@value['@context'] if @value.is_a?(Hash)) || context_ref
       @context = Context.parse(context || {}, @options)
 
+      # If not set explicitly, the context figures out the processing mode
+      @options[:processingMode] ||= @context.processingMode
+      @options[:validate] ||= %w(json-ld-1.0 json-ld-1.1).include?(@options[:processingMode])
+
       if block_given?
         case block.arity
           when 0, -1 then instance_eval(&block)

lib/json/ld/context.rb

@@ -205,6 +205,9 @@ def inspect
     # @return [BlankNodeNamer]
     attr_accessor :namer
 
+    # @return [String]
+    attr_accessor :processingMode
+
     ##
     # Create a new context by parsing a context.
     #
@@ -242,6 +245,7 @@ def initialize(**options)
         @doc_base.canonicalize! if options[:canonicalize]
       end
       options[:documentLoader] ||= JSON::LD::API.method(:documentLoader)
+      @processingMode ||= options[:processingMode]
       @term_definitions = {}
       @iri_to_term = {
         RDF.to_uri.to_s => "rdf",
@@ -302,6 +306,22 @@ def default_language=(value)
       end
     end
 
+    # If contex has a @version member, it's value MUST be 1.1, otherwise an "invalid @version value" has been detected, and processing is aborted.
+    #   If processingMode has been set, and "json-ld-1.1" is not a prefix of processingMode , a "processing mode conflict" has been detecting, and processing is aborted.
+    # @param [Number] vaule must be a decimal number
+    def version=(value)
+      case value
+      when 1.1
+        if processingMode && !processingMode.start_with?("json-ld-1.1")
+          raise JsonLdError::ProcessingModeConflict, "#{value} not compatible with #{processingMode}"
+        end
+        @processingMode ||= "json-ld-1.1"
+      else
+        raise JsonLdError::InvalidVersionValue, value
+      end
+    end
+
+    # If context has a @vocab member: if its value is not a valid absolute IRI or null trigger an INVALID_VOCAB_MAPPING error; otherwise set the active context's vocabulary mapping to its value and remove the @vocab member from context.
     # @param [String] value must be an absolute IRI
     def vocab=(value)
       @vocab = case value
@@ -399,7 +419,7 @@ def parse(local_context, remote_contexts = [])
                 end
                 raise JsonLdError::InvalidRemoteContext, "#{context}" unless jo.is_a?(Hash) && jo.has_key?('@context')
                 context = jo['@context']
-                if @options[:processingMode] == "json-ld-1.0"
+                if processingMode && processingMode <= "json-ld-1.1"
                   context_no_base.provided_context = context.dup
                 end
               end
@@ -421,11 +441,12 @@ def parse(local_context, remote_contexts = [])
           result = context
           #log_debug("parse") {"=> provided_context: #{context.inspect}"}
         when Hash
-          # If context has a @vocab member: if its value is not a valid absolute IRI or null trigger an INVALID_VOCAB_MAPPING error; otherwise set the active context's vocabulary mapping to its value and remove the @vocab member from context.
           context = context.dup # keep from modifying a hash passed as a param
+
           {
             '@base'     => :base=,
             '@language' => :default_language=,
+            '@version'  => :version=,
             '@vocab'    => :vocab=,
           }.each do |key, setter|
             v = context.fetch(key, false)
@@ -436,6 +457,9 @@ def parse(local_context, remote_contexts = [])
             end
           end
 
+          # If not set explicitly, set processingMode to "json-ld-1.0"
+          result.processingMode ||= "json-ld-1.0"
+
           defined = {}
         # For each key-value pair in context invoke the Create Term Definition subalgorithm, passing result for active context, context for local context, key, and defined
           context.each_key do |key|
@@ -504,7 +528,7 @@ def create_term_definition(local_context, term, defined)
       end
 
       # Since keywords cannot be overridden, term must not be a keyword. Otherwise, an invalid value has been detected, which is an error.
-      if KEYWORDS.include?(term) && !%w(@vocab @language).include?(term)
+      if KEYWORDS.include?(term) && !%w(@vocab @language @version).include?(term)
         raise JsonLdError::KeywordRedefinition, "term must not be a keyword: #{term.inspect}" if
           @options[:validate]
       elsif !term_valid?(term) && @options[:validate]
@@ -581,11 +605,10 @@ def create_term_definition(local_context, term, defined)
           # If value contains an @container member, set the container mapping of definition to its value; if its value is neither @set, @index, @type, @id, an absolute IRI nor null, an invalid reverse property error has been detected (reverse properties only support set- and index-containers) and processing is aborted.
           if value.has_key?('@container')
             container = value['@container']
-            # FIXME: Are URIS, @id, and @type reasonable for reverse mappings?
             raise JsonLdError::InvalidReverseProperty,
-                   "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" if
-                    %w(@language @list).include?(container)
-              definition.container_mapping = check_container(container, local_context, defined, term)
+                  "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" unless
+                   ['@set', '@index'].include?(container)
+            definition.container_mapping = check_container(container, local_context, defined, term)
           end
           definition.reverse_property = true
         elsif value.has_key?('@id') && value['@id'] != term
@@ -626,9 +649,8 @@ def create_term_definition(local_context, term, defined)
         end
 
         if value.has_key?('@context')
-          context = value['@context']
           # Not supported in JSON-LD 1.0
-          raise JsonLdError::InvalidScopedContext, '@context not valid in term definition' if @options[:processingMode] < 'json-ld-1.1'
+          raise JsonLdError::InvalidTermDefinition, '@context not valid in term definition for JSON-LD 1.0' if processingMode < 'json-ld-1.1'
 
           begin
             self.parse(value['@context'])
@@ -647,6 +669,12 @@ def create_term_definition(local_context, term, defined)
         end
 
         if value.has_key?('@nest')
+          # Not supported in JSON-LD 1.0
+          raise JsonLdError::InvalidTermDefinition, '@nest not valid in term definition for JSON-LD 1.0' if processingMode < 'json-ld-1.1'
+
+          # Not supported in JSON-LD 1.0
+          raise JsonLdError::InvalidTermDefinition, '@nest not valid in term definition for JSON-LD 1.0' if processingMode < 'json-ld-1.1'
+
           nest = value['@nest']
           raise JsonLdError::InvalidNestValue, "nest must be a string, was #{nest.inspect}} on term #{term.inspect}" unless nest.is_a?(String)
           raise JsonLdError::InvalidNestValue, "nest must not be a keyword other than @nest, was #{nest.inspect}} on term #{term.inspect}" if nest.start_with?('@') && nest != '@nest'
@@ -1310,6 +1338,7 @@ def inspect
       v = %w([Context)
       v << "base=#{base}" if base
       v << "vocab=#{vocab}" if vocab
+      v << "processingMode=#{processingMode}" if processingMode
       v << "default_language=#{default_language}" if default_language
       v << "term_definitions[#{term_definitions.length}]=#{term_definitions}"
       v.join(" ") + "]"
@@ -1538,7 +1567,7 @@ def check_container(container, local_context, defined, term)
       when '@type', '@id', nil
         raise JsonLdError::InvalidContainerMapping,
               "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" if
-              @options[:processingMode] < 'json-ld-1.1'
+              processingMode < 'json-ld-1.1'
       else
         raise JsonLdError::InvalidContainerMapping,
               "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}"

spec/compact_spec.rb

@@ -572,7 +572,7 @@
           })
         },
       }.each_pair do |title, params|
-        it(title) {run_compact(params)}
+        it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
     end
 
@@ -677,7 +677,7 @@
           })
         },
       }.each_pair do |title, params|
-        it(title) {run_compact(params)}
+        it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
     end
 
@@ -926,9 +926,9 @@
             "term": {"@id": "http://example/foo", "@nest": "unknown"}
           }),
           exception: JSON::LD::JsonLdError::InvalidNestValue
-        }
+        },
       }.each_pair do |title, params|
-        it(title) {run_compact(params)}
+        it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
     end
 
@@ -1075,8 +1075,19 @@
             "c": "C in example"
           }),
         },
+        "Raises InvalidTermDefinition if processingMode is not specified" => {
+          input: %([{
+            "http://example/foo": [{"http://example.org/bar": [{"@value": "baz"}]}]
+          }]),
+          context: %({
+            "@vocab": "http://example/",
+            "foo": {"@context": {"bar": "http://example.org/bar"}}
+          }),
+          processingMode: nil,
+          exception: JSON::LD::JsonLdError::InvalidTermDefinition
+        },
       }.each_pair do |title, params|
-        it(title) {run_compact(params)}
+        it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
     end
 
@@ -1219,8 +1230,24 @@
             }
           })
         },
+        "Raises InvalidTermDefinition if processingMode is not specified" => {
+          input: %([
+            {
+              "http://example/a": [{
+                "@type": ["http://example/Foo"],
+                "http://example.org/bar": [{"@value": "baz"}]
+              }]
+            }
+          ]),
+          context: %({
+            "@vocab": "http://example/",
+            "Foo": {"@context": {"bar": "http://example.org/bar"}}
+          }),
+          processingMode: nil,
+          exception: JSON::LD::JsonLdError::InvalidTermDefinition
+        },
       }.each_pair do |title, params|
-        it(title) {run_compact(params)}
+        it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
     end
 
@@ -1248,15 +1275,15 @@
   end
 
   def run_compact(params)
-    input, output, context = params[:input], params[:output], params[:context]
+    input, output, context, processingMode = params[:input], params[:output], params[:context], params[:processingMode]
     input = ::JSON.parse(input) if input.is_a?(String)
     output = ::JSON.parse(output) if output.is_a?(String)
     context = ::JSON.parse(context) if context.is_a?(String)
     pending params.fetch(:pending, "test implementation") unless input
     if params[:exception]
-      expect {JSON::LD::API.compact(input, context, logger: logger)}.to raise_error(params[:exception])
+      expect {JSON::LD::API.compact(input, context, logger: logger, processingMode: processingMode)}.to raise_error(params[:exception])
     else
-      jld = JSON::LD::API.compact(input, context, logger: logger)
+      jld = JSON::LD::API.compact(input, context, logger: logger, processingMode: processingMode)
       expect(jld).to produce(output, logger)
     end
   end

spec/context_spec.rb

@@ -112,7 +112,7 @@ def containers
         let(:ctx) {"http://example.com/preloaded"}
         before(:all) {
           JSON::LD::Context.add_preloaded("http://example.com/preloaded",
-          JSON::LD::Context.new().parse({'foo' => "http://example.com/"})
+          JSON::LD::Context.parse({'foo' => "http://example.com/"})
         )}
         after(:all) {JSON::LD::Context::PRELOADED.clear}
 
@@ -362,9 +362,50 @@ def containers
     end
   end
 
+  describe "#processingMode" do
+    it "sets to json-ld-1.0 if not specified" do
+      [
+        %({}),
+        %([{}]),
+      ].each do |str|
+        ctx = JSON::LD::Context.parse(::JSON.parse(str))
+        expect(ctx.processingMode).to eql "json-ld-1.0"
+      end
+    end
+
+    it "sets to json-ld-1.1 if @version: 1.1" do
+      [
+        %({"@version": 1.1}),
+        %([{"@version": 1.1}]),
+      ].each do |str|
+        ctx = JSON::LD::Context.parse(::JSON.parse(str))
+        expect(ctx.processingMode).to eql "json-ld-1.1"
+      end
+    end
+
+    it "raises InvalidVersionValue if @version out of scope" do
+      [
+        "1.1",
+        "1.0",
+        1.0,
+        "foo"
+      ].each do |vers|
+        expect {JSON::LD::Context.parse({"@version" => vers})}.to raise_error(JSON::LD::JsonLdError::InvalidVersionValue)
+      end
+    end
+
+    it "raises ProcessingModeConflict if provided processing mode conflicts with context" do
+      expect {JSON::LD::Context.parse({"@version" => 1.1}, processingMode: "json-ld-1.0")}.to raise_error(JSON::LD::JsonLdError::ProcessingModeConflict)
+    end
+
+    it "raises ProcessingModeConflict nested context is different from starting context" do
+      expect {JSON::LD::Context.parse([{}, {"@version" => 1.1}])}.to raise_error(JSON::LD::JsonLdError::ProcessingModeConflict)
+    end
+  end
+
   describe "#merge" do
     it "creates a new context with components of each" do
-      c2 = JSON::LD::Context.new().parse({'foo' => "http://example.com/"})
+      c2 = JSON::LD::Context.parse({'foo' => "http://example.com/"})
       cm = context.merge(c2)
       expect(cm).not_to equal context
       expect(cm).not_to equal c2
@@ -374,7 +415,7 @@ def containers
 
   describe "#merge!" do
     it "updates context with components from new" do
-      c2 = JSON::LD::Context.new().parse({'foo' => "http://example.com/"})
+      c2 = JSON::LD::Context.parse({'foo' => "http://example.com/"})
       cm = context.merge!(c2)
       expect(cm).to equal context
       expect(cm).not_to equal c2