json-ld 2.1.4 → 2.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d25a036d130e6e5442d6a1ce31847926874bce11
-  data.tar.gz: 4ef35668b4fd657f9fd2b26058fe336d20cbbb3d
+  metadata.gz: 87b6c40e1f1bff540f8c175e321087f60a7a6c04
+  data.tar.gz: eeba4194d6cb10caa31214444882c18e8688d44c
 SHA512:
-  metadata.gz: def848f7294bc73b90d653579509c9e1dea81adb48b457bd85e30f307eecff4b416d57ef42f29d0aff5c11da8d979632a6c0e893b62fd66ba42dc52309e39ea1
-  data.tar.gz: 00e042aaebf1efa94822a21878c35046129469ceb9ec50dfea5923189b3c7ac7cc24a9a5bf99eeef74d5dbcc378dd6e2c3596343370163addd064ff758a4a316
+  metadata.gz: 972abe58a807190d6cb9228f80abec5198012c4c395973025b4ca50f5ea54142170999f7210769c621861e5136704dabc2f99932ab62dc9f7c9516b7ba931ae8
+  data.tar.gz: db37dac97ad2569415b35bff8e1967d0126621dd978cc183e0d80e3dc998e2c4592a1e4f94bd5ffe39f35cb207867db6fe986092fb416fc9cd9266a6c103ad74

data/VERSION

@@ -1 +1 @@
-2.1.4
+2.1.5

data/bin/jsonld

@@ -115,7 +115,6 @@ OPT_ARGS = [
   ["--quiet",         GetoptLong::NO_ARGUMENT,      "Supress most output other than progress indicators"],
   ["--rename_bnodes", GetoptLong::OPTIONAL_ARGUMENT,"Rename bnodes as part of expansion, or keep them the same"],
   ["--requireAll",    GetoptLong::OPTIONAL_ARGUMENT,"Rename bnodes as part of expansion, or keep them the same"],
-  ["--simple_compact_iris",GetoptLong::OPTIONAL_ARGUMENT,"When compacting IRIs, do not use terms with expanded term definitions"],
   ["--stream",        GetoptLong::NO_ARGUMENT,      "Use Streaming reader/writer"],
   ["--unique_bnodes", GetoptLong::OPTIONAL_ARGUMENT,"Use unique bnode identifiers"],
   ["--uri",           GetoptLong::REQUIRED_ARGUMENT,"URI to be used as the document base"],

data/lib/json/ld.rb

@@ -115,6 +115,7 @@ module JSON
       class InvalidLanguageTaggedValue < JsonLdError; @code = "invalid language-tagged value"; end
       class InvalidLocalContext < JsonLdError; @code = "invalid local context"; end
       class InvalidNestValue < JsonLdError; @code = "invalid @nest value"; end
+      class InvalidPrefixValue < JsonLdError; @code = "invalid @prefix value"; end
       class InvalidRemoteContext < JsonLdError; @code = "invalid remote context"; end
       class InvalidReverseProperty < JsonLdError; @code = "invalid reverse property"; end
       class InvalidReversePropertyMap < JsonLdError; @code = "invalid reverse property map"; end

data/lib/json/ld/api.rb

@@ -63,6 +63,8 @@ module JSON::LD
     #   The Base IRI to use when expanding the document. This overrides the value of `input` if it is a _IRI_. If not specified and `input` is not an _IRI_, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from `input`, options[:base] will be modified with this value.
     # @option options [Boolean] :compactArrays (true)
     #   If set to `true`, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to `false`, all arrays will remain arrays even if they have just one element.
+    # @option options [Boolean] :compactToRelative (true)
+    #   Creates document relative IRIs when compacting, if `true`, otherwise leaves expanded.
     # @option options [Proc] :documentLoader
     #   The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See {documentLoader} for the method signature.
     # @option options [String, #read, Hash, Array, JSON::LD::Context] :expandContext
@@ -79,8 +81,6 @@ module JSON::LD
     #   Rename bnodes as part of expansion, or keep them the same.
     # @option options [Boolean]  :unique_bnodes   (false)
     #   Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
-    # @option options [Boolean]  :simple_compact_iris   (false)
-    #   When compacting IRIs, do not use terms with expanded term definitions
     # @option options [Symbol] :adapter used with MultiJson
     # @option options [Boolean] :validate Validate input, if a string or readable object.
     # @yield [api]
@@ -88,20 +88,19 @@ module JSON::LD
     # @raise [JsonLdError]
     def initialize(input, context, options = {}, &block)
       @options = {
-        compactArrays: true,
-        rename_bnodes: true,
-        documentLoader: self.class.method(:documentLoader)
-      }
-      @options = @options.merge(options)
+        compactArrays:      true,
+        rename_bnodes:      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
       when IO, StringIO
-        @options = {base: input.base_uri}.merge!(@options) if input.respond_to?(:base_uri)
+        @options = {base: input.base_uri}.merge(@options) if input.respond_to?(:base_uri)
 
         # if input impelements #links, attempt to get a contextUrl from that link
         content_type = input.respond_to?(:content_type) ? input.content_type : "application/json"
@@ -116,8 +115,9 @@ module JSON::LD
       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
@@ -128,9 +128,6 @@ module JSON::LD
         end
       end
 
-      # Update calling context :base option, if not defined
-      options[:base] ||= @options[:base] if @options[:base]
-
       # If not provided, first use context from document, or from a Link header
       context ||= (@value['@context'] if @value.is_a?(Hash)) || context_ref
       @context = Context.parse(context || {}, @options)
@@ -160,17 +157,20 @@ module JSON::LD
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
     # @raise [JsonLdError]
-    # @yield jsonld
+    # @yield jsonld, base_iri
     # @yieldparam [Array<Hash>] jsonld
     #   The expanded JSON-LD document
+    # @yieldparam [RDF::URI] base_iri
+    #   The document base as determined during expansion
     # @yieldreturn [Object] returned object
     # @return [Object, Array<Hash>]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
     # @see http://json-ld.org/spec/latest/json-ld-api/#expansion-algorithm
-    def self.expand(input, options = {})
-      result = nil
-      API.new(input, options[:expandContext], options) do |api|
-        result = api.expand(api.value, nil, api.context, ordered: options.fetch(:ordered, true))
+    def self.expand(input, options = {}, &block)
+      result, doc_base = nil
+      API.new(input, options[:expandContext], options) do
+        result = self.expand(self.value, nil, self.context, ordered: options.fetch(:ordered, true))
+        doc_base = @options[:base]
       end
 
       # If, after the algorithm outlined above is run, the resulting element is an JSON object with just a @graph property, element is set to the value of @graph's value.
@@ -178,7 +178,17 @@ module JSON::LD
 
       # Finally, if element is a JSON object, it is wrapped into an array.
       result = [result].compact unless result.is_a?(Array)
-      block_given? ? yield(result) : result
+
+      if block_given?
+        case block.arity
+        when 1 then yield(result)
+        when 2 then yield(result, doc_base)
+        else
+          raise "Unexpected number of yield parameters to expand"
+        end
+      else
+        result
+      end
     end
 
     ##
@@ -204,13 +214,17 @@ module JSON::LD
     # @raise [JsonLdError]
     # @see http://json-ld.org/spec/latest/json-ld-api/#compaction-algorithm
     def self.compact(input, context, options = {})
-      expanded = result = nil
+      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)
+      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
+        options[:base] ||= base_iri if options[:compactToRelative]
+        result
+      end
 
-      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)
 
@@ -246,12 +260,16 @@ module JSON::LD
     # @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)
+      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, 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.
@@ -316,13 +334,14 @@ module JSON::LD
       options = {
         base:                       (input if input.is_a?(String)),
         compactArrays:              true,
+        compactToRelative:          true,
         embed:                      '@last',
         explicit:                   false,
         requireAll:                 true,
         omitDefault:                false,
         pruneBlankNodeIdentifiers:  true,
         documentLoader:             method(:documentLoader)
-      }.merge!(options)
+      }.merge(options)
 
       framing_state = {
         graphMap:     {},
@@ -344,13 +363,16 @@ module JSON::LD
       end
 
       # Expand input to simplify processing
-      expanded_input = options[:expanded] ? input : API.expand(input, options)
+      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, 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

data/lib/json/ld/context.rb

@@ -58,6 +58,9 @@ module JSON::LD
       # @return [Boolean]
       attr_accessor :simple
 
+      # Indicate that term may be used as a prefix
+      attr_writer :prefix
+
       # Term-specific context
       # @return [Hash{String => Object}]
       attr_accessor :context
@@ -66,6 +69,10 @@ module JSON::LD
       # @return [Boolean] simple
       def simple?; simple; end
 
+      # This is an appropriate term to use as the prefix of a compact IRI
+      # @return [Boolean] simple
+      def prefix?; @prefix; end
+
       # Create a new Term Mapping with an ID
       # @param [String] term
       # @param [String] id
@@ -77,6 +84,8 @@ module JSON::LD
       # @param [String] nest term used for nest properties
       # @param [Boolean] simple
       #   This is a simple term definition, not an expanded term definition
+      # @param [Boolean] prefix
+      #   Term may be used as a prefix
       def initialize(term,
                     id: nil,
                     type_mapping: nil,
@@ -85,16 +94,18 @@ module JSON::LD
                     reverse_property: false,
                     nest: nil,
                     simple: false,
+                    prefix: nil,
                     context: nil)
         @term                   = term
-        @id                     = id.to_s           if id
-        @type_mapping           = type_mapping.to_s if type_mapping
-        self.container_mapping  = container_mapping if container_mapping
-        @language_mapping       = language_mapping  if language_mapping
-        @reverse_property       = reverse_property  if reverse_property
-        @nest                   = nest              if nest
-        @simple                 = simple            if simple
-        @context                = context           if context
+        @id                     = id.to_s           unless id.nil?
+        @type_mapping           = type_mapping.to_s unless type_mapping.nil?
+        self.container_mapping  = container_mapping unless container_mapping.nil?
+        @language_mapping       = language_mapping  unless language_mapping.nil?
+        @reverse_property       = reverse_property
+        @nest                   = nest              unless nest.nil?
+        @simple                 = simple
+        @prefix                 = prefix            unless prefix.nil?
+        @context                = context           unless context.nil?
       end
 
       # Set container mapping, from an array which may include @set
@@ -121,14 +132,7 @@ module JSON::LD
           iri && iri != id ? "#{prefix}:#{id.to_s[iri.length..-1]}" : id
         end
 
-        if language_mapping.nil? &&
-           container_mapping.nil? &&
-           !as_set &&
-           type_mapping.nil? &&
-           reverse_property.nil? &&
-           self.context.nil? &&
-           nest.nil?
-
+        if simple?
            cid.to_s unless cid == term && context.vocab
         else
           defn = {}
@@ -145,9 +149,10 @@ module JSON::LD
           cm = cm.first if cm.length == 1
           defn['@container'] = cm unless cm.empty?
           # Language set as false to be output as null
-          defn['@language'] = (language_mapping ? language_mapping : nil) unless language_mapping.nil?
-          defn['@context'] = self.context unless self.context.nil?
-          defn['@nest'] = selfnest unless self.nest.nil?
+          defn['@language'] = (@language_mapping ? @language_mapping : nil) unless @language_mapping.nil?
+          defn['@context'] = @context if @context
+          defn['@nest'] = @nest if @nest
+          defn['@prefix'] = @prefix unless @prefix.nil? || (context.processingMode || 'json-ld-1.0') == 'json-ld-1.0'
           defn
         end
       end
@@ -158,7 +163,7 @@ module JSON::LD
       # @return [String]
       def to_rb
         defn = [%(TermDefinition.new\(#{term.inspect})]
-        %w(id type_mapping container_mapping language_mapping reverse_property nest simple context).each do |acc|
+        %w(id type_mapping container_mapping language_mapping reverse_property nest simple prefix context).each do |acc|
           v = instance_variable_get("@#{acc}".to_sym)
           v = v.to_s if v.is_a?(RDF::Term)
           if acc == 'container_mapping' && as_set
@@ -179,6 +184,8 @@ module JSON::LD
         v << "lang=#{language_mapping.inspect}" unless language_mapping.nil?
         v << "type=#{type_mapping}" unless type_mapping.nil?
         v << "nest=#{nest.inspect}" unless nest.nil?
+        v << "simple=true" if @simple
+        v << "prefix=#{@prefix.inspect}" unless @prefix.nil?
         v << "has-context" unless context.nil?
         v.join(" ") + "]"
       end
@@ -194,7 +201,7 @@ module JSON::LD
     # @return [RDF::URI] Document base IRI, to initialize `base`.
     attr_reader :doc_base
 
-    # @return [RDF::URI] base IRI of the context, if loaded remotely. XXX
+    # @return [RDF::URI] base IRI of the context, if loaded remotely.
     attr_accessor :context_base
 
     # Term definitions
@@ -252,8 +259,6 @@ module JSON::LD
     #   The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See {API.documentLoader} for the method signature.
     # @option options [Hash{Symbol => String}] :prefixes
     #   See `RDF::Reader#initialize`
-    # @option options [Boolean]  :simple_compact_iris   (false)
-    #   When compacting IRIs, do not use terms with expanded term definitions
     # @option options [String, #to_s] :vocab
     #   Initial value for @vocab
     # @option options [String, #to_s] :language
@@ -281,8 +286,7 @@ module JSON::LD
       (options[:prefixes] || {}).each_pair do |k, v|
         next if k.nil?
         @iri_to_term[v.to_s] = k
-        @term_definitions[k.to_s] = TermDefinition.new(k, id: v.to_s)
-        @term_definitions[k.to_s].simple = true
+        @term_definitions[k.to_s] = TermDefinition.new(k, id: v.to_s, simple: true, prefix: true)
       end
 
       self.vocab = options[:vocab] if options[:vocab]
@@ -441,7 +445,7 @@ module JSON::LD
                 end
                 raise JsonLdError::InvalidRemoteContext, "#{context}" unless jo.is_a?(Hash) && jo.has_key?('@context')
                 context = jo['@context']
-                if processingMode && processingMode <= "json-ld-1.1"
+                if  (processingMode || 'json-ld-1.0') <= "json-ld-1.1"
                   context_no_base.provided_context = context.dup
                 end
               end
@@ -563,7 +567,7 @@ module JSON::LD
       # Initialize value to a the value associated with the key term in local context.
       value = local_context.fetch(term, false)
       simple_term = value.is_a?(String)
-      value = {'@id' => value} if value.is_a?(String)
+      value = {'@id' => value} if simple_term
 
       case value
       when nil, {'@id' => nil}
@@ -577,9 +581,9 @@ module JSON::LD
         definition = TermDefinition.new(term)
         definition.simple = simple_term
 
-        expected_keys = case @options[:processingMode]
-        when "json-ld-1.0" then %w(@id @reverse @type @container @language)
-        else  %w(@id @reverse @type @container @language @context @nest)
+        expected_keys = case processingMode
+        when "json-ld-1.0", nil then %w(@container @id @language @reverse @type)
+        else  %w(@container @context @id @language @nest @prefix @reverse @type)
         end
 
         extra_keys = value.keys - expected_keys
@@ -643,6 +647,11 @@ module JSON::LD
             defined: defined)
           raise JsonLdError::InvalidKeywordAlias, "expected value of @id to not be @context on term #{term.inspect}" if
             definition.id == '@context'
+
+            # If id ends with a gen-delim, it may be used as a prefix
+            definition.prefix = true if !term.include?(':') &&
+              definition.id.to_s.end_with?(*%w(: / ? # [ ] @)) &&
+              (simple_term || ((processingMode || 'json-ld-1.0') == 'json-ld-1.0'))
         elsif term.include?(':')
           # If term is a compact IRI with a prefix that is a key in local context then a dependency has been found. Use this algorithm recursively passing active context, local context, the prefix as term, and defined.
           prefix, suffix = term.split(':')
@@ -671,9 +680,6 @@ module JSON::LD
         end
 
         if value.has_key?('@context')
-          # Not supported in JSON-LD 1.0
-          raise JsonLdError::InvalidTermDefinition, '@context not valid in term definition for JSON-LD 1.0 on term #{term.inspect}, set processing mode using @version' if processingMode < 'json-ld-1.1'
-
           begin
             self.parse(value['@context'])
             definition.context = value['@context']
@@ -691,12 +697,6 @@ module JSON::LD
         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 on term #{term.inspect}, set processing mode using @version' 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 on term #{term.inspect}, set processing mode using @version' 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'
@@ -704,6 +704,16 @@ module JSON::LD
           definition.nest = nest
         end
 
+        if value.has_key?('@prefix')
+          raise JsonLdError::InvalidTermDefinition, "@prefix used on compact IRI term #{term.inspect}" if term.include?(':')
+          case pfx = value['@prefix']
+          when TrueClass, FalseClass
+            definition.prefix = pfx
+          else
+            raise JsonLdError::InvalidPrefixValue, "unknown value for '@prefix': #{pfx.inspect} on term #{term.inspect}"
+          end
+        end
+
         term_definitions[term] = definition
         defined[term] = true
       else
@@ -839,7 +849,7 @@ module JSON::LD
     def set_mapping(term, value)
       #log_debug("") {"map #{term.inspect} to #{value.inspect}"}
       term = term.to_s
-      term_definitions[term] = TermDefinition.new(term, id: value)
+      term_definitions[term] = TermDefinition.new(term, id: value, simple: true, prefix: (value.to_s.end_with?(*%w(: / ? # [ ] @))))
       term_definitions[term].simple = true
 
       term_sym = term.empty? ? "" : term.to_sym
@@ -1052,7 +1062,7 @@ module JSON::LD
 
       if vocab && inverse_context.has_key?(iri)
         #log_debug("") {"vocab and key in inverse context"} unless quiet
-        default_language = self.default_language || @none
+        default_language = self.default_language || "@none"
         containers = []
         tl, tl_value = "@language", "@null"
 
@@ -1136,7 +1146,8 @@ module JSON::LD
             preferred_values.concat(%w(@id @vocab @none))
           end
         else
-          preferred_values.concat([tl_value, '@none'])
+          tl = '@any' if list?(value) && value['@list'].empty?
+          preferred_values.concat([tl_value, '@none'].compact)
         end
         #log_debug("") {"preferred_values: #{preferred_values.inspect}"} unless quiet
         if p_term = select_term(iri, containers, tl, preferred_values)
@@ -1156,21 +1167,17 @@ module JSON::LD
       candidates = []
 
       term_definitions.each do |term, td|
-        next if term.include?(":")
         next if td.nil? || td.id.nil? || td.id == iri || !iri.start_with?(td.id)
 
-        # Also skip term if it was not a simple term and the :simple_compact_iris flag is true
-        next if @options[:simple_compact_iris] && !td.simple?
+        # Skip term if `@prefix` is not true in term definition
+        next unless td.prefix?
 
         suffix = iri[td.id.length..-1]
         ciri = "#{term}:#{suffix}"
         candidates << ciri unless value && term_definitions.has_key?(ciri)
       end
 
-      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
@@ -1183,10 +1190,7 @@ module JSON::LD
             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
@@ -1483,9 +1487,11 @@ module JSON::LD
           next unless td = term_definitions[term]
           container = td.container_mapping || (td.as_set ? '@set' : '@none')
           container_map = result[td.id.to_s] ||= {}
-          tl_map = container_map[container] ||= {'@language' => {}, '@type' => {}}
+          tl_map = container_map[container] ||= {'@language' => {}, '@type' => {}, '@any' => {}}
           type_map = tl_map['@type']
           language_map = tl_map['@language']
+          any_map = tl_map['@any']
+          any_map['@none'] ||= term
           if td.reverse_property
             type_map['@reverse'] ||= term
           elsif td.type_mapping
@@ -1598,7 +1604,7 @@ module JSON::LD
     # Ensure @container mapping is appropriate
     # The result is the original container definition. For IRI containers, this is necessary to be able to determine the @type mapping for string values
     def check_container(container, local_context, defined, term)
-      if container.is_a?(Array) && processingMode < 'json-ld-1.1'
+      if container.is_a?(Array) &&  (processingMode || 'json-ld-1.0') < 'json-ld-1.1'
         raise JsonLdError::InvalidContainerMapping,
               "'@container' on term #{term.inspect} must be a string: #{container.inspect}"
       end
@@ -1619,7 +1625,7 @@ module JSON::LD
       when '@type', '@id', nil
         raise JsonLdError::InvalidContainerMapping,
               "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" if
-              processingMode < 'json-ld-1.1'
+               (processingMode || 'json-ld-1.0') < 'json-ld-1.1'
       else
         raise JsonLdError::InvalidContainerMapping,
               "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}"

data/lib/json/ld/frame.rb

@@ -224,7 +224,6 @@ module JSON::LD
         output = Hash.new
         input.each do |key, value|
           if key == '@preserve'
-            #require 'byebug'; byebug
             # replace all key-value pairs where the key is @preserve with the value from the key-pair
             output = cleanup_preserve(value, bnodes_to_clear)
           elsif context.expand_iri(key) == '@id' && bnodes_to_clear.include?(value)

data/lib/json/ld/writer.rb

@@ -77,6 +77,11 @@ module JSON::LD
           datatype: TrueClass,
           on: ["--compact-arrays"],
           description: "Replaces arrays with just one element with that element during compaction.") {true},
+        RDF::CLI::Option.new(
+          symbol: :compactToRelative,
+          datatype: TrueClass,
+          on: ["--compact-to-relative"],
+          description: "Creates document relative IRIs when compacting, if `true`, otherwise leaves expanded. Default is `true` use --no-compact-to-relative to disable.") {true},
         RDF::CLI::Option.new(
           symbol: :context,
           datatype: RDF::URI,

data/spec/compact_spec.rb

@@ -299,6 +299,69 @@ describe JSON::LD::API do
       end
     end
 
+    context "IRI Compaction" do
+      {
+        "Expands and compacts to document base in 1.0" => {
+          input: %({
+            "@id": "a",
+            "http://example.com/b": {"@id": "c"}
+          }),
+          context: %({"b": "http://example.com/b"}),
+          output: %({
+            "@context": {"b": "http://example.com/b"},
+            "@id": "a",
+            "b": {"@id": "c"}
+          }),
+          base: "http://example.org/"
+        },
+        "Expands and compacts to document base in 1.1 with compactToRelative true" => {
+          input: %({
+            "@id": "a",
+            "http://example.com/b": {"@id": "c"}
+          }),
+          context: %({"b": "http://example.com/b"}),
+          output: %({
+            "@context": {"b": "http://example.com/b"},
+            "@id": "a",
+            "b": {"@id": "c"}
+          }),
+          base: "http://example.org/",
+          compactToRelative: true,
+          processingMode: 'json-ld-1.1'
+        },
+        "Expands but does not compact to document base in 1.1 with compactToRelative false" => {
+          input: %({
+            "@id": "http://example.org/a",
+            "http://example.com/b": {"@id": "http://example.org/c"}
+          }),
+          context: %({"b": "http://example.com/b"}),
+          output: %({
+            "@context": {"b": "http://example.com/b"},
+            "@id": "http://example.org/a",
+            "b": {"@id": "http://example.org/c"}
+          }),
+          compactToRelative: false,
+          processingMode: 'json-ld-1.1'
+        },
+        "Expands and compacts to document base in 1.1 by default" => {
+          input: %({
+            "@id": "a",
+            "http://example.com/b": {"@id": "c"}
+          }),
+          context: %({"b": "http://example.com/b"}),
+          output: %({
+            "@context": {"b": "http://example.com/b"},
+            "@id": "a",
+            "b": {"@id": "c"}
+          }),
+          base: "http://example.org/",
+          processingMode: 'json-ld-1.1'
+        },
+      }.each_pair do |title, params|
+        it(title) {run_compact(params)}
+      end
+    end
+
     context "@container: @reverse" do
       {
         "@container: @reverse" => {
@@ -1084,6 +1147,7 @@ describe JSON::LD::API do
             "foo": {"@context": {"bar": "http://example.org/bar"}}
           }),
           processingMode: nil,
+          validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
       }.each_pair do |title, params|
@@ -1244,6 +1308,7 @@ describe JSON::LD::API do
             "Foo": {"@context": {"bar": "http://example.org/bar"}}
           }),
           processingMode: nil,
+          validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
       }.each_pair do |title, params|
@@ -1272,18 +1337,107 @@ describe JSON::LD::API do
         it(title) {run_compact(params)}
       end
     end
+
+    context "compact IRI selection" do
+      {
+        "compacts using expanded term in 1.0" => {
+          input: %({"http://example.org/foo": "term"}),
+          context: %({"ex": {"@id": "http://example.org/"}}),
+          output: %({
+            "@context": {"ex": {"@id": "http://example.org/"}},
+            "ex:foo": "term"
+          }),
+          processingMode: "json-ld-1.0"
+        },
+        "does not compact using expanded term in 1.1" => {
+          input: %({"http://example.org/foo": "term"}),
+          context: %({"ex": {"@id": "http://example.org/"}}),
+          output: %({
+            "@context": {"ex": {"@id": "http://example.org/"}},
+            "http://example.org/foo": "term"
+          }),
+          processingMode: "json-ld-1.1"
+        },
+        "does not compact using simple term not ending in gen-delim" => {
+          input: %({"http://example.org/foo": "term"}),
+          context: %({"ex": "http://example.org/f"}),
+          output: %({
+            "@context": {"ex": "http://example.org/f"},
+            "http://example.org/foo": "term"
+          })
+        },
+        "compacts using simple term ending in gen-delim ('/')" => {
+          input: %({"http://example.org/foo": "term"}),
+          context: %({"ex": "http://example.org/"}),
+          output: %({
+            "@context": {"ex": "http://example.org/"},
+            "ex:foo": "term"
+          })
+        },
+        "compacts using simple term ending in gen-delim (':')" => {
+          input: %({"http://example.org/foo:bar": "term"}),
+          context: %({"ex": "http://example.org/foo:"}),
+          output: %({
+            "@context": {"ex": "http://example.org/foo:"},
+            "ex:bar": "term"
+          })
+        },
+        "compacts using simple term ending in gen-delim ('?')" => {
+          input: %({"http://example.org/foo?bar": "term"}),
+          context: %({"ex": "http://example.org/foo?"}),
+          output: %({
+            "@context": {"ex": "http://example.org/foo?"},
+            "ex:bar": "term"
+          })
+        },
+        "compacts using simple term ending in gen-delim ('#')" => {
+          input: %({"http://example.org/foo#bar": "term"}),
+          context: %({"ex": "http://example.org/foo#"}),
+          output: %({
+            "@context": {"ex": "http://example.org/foo#"},
+            "ex:bar": "term"
+          })
+        },
+        "compacts using simple term ending in gen-delim ('[')" => {
+          input: %({"http://example.org/foo[bar": "term"}),
+          context: %({"ex": "http://example.org/foo["}),
+          output: %({
+            "@context": {"ex": "http://example.org/foo["},
+            "ex:bar": "term"
+          })
+        },
+        "compacts using simple term ending in gen-delim (']')" => {
+          input: %({"http://example.org/foo]bar": "term"}),
+          context: %({"ex": "http://example.org/foo]"}),
+          output: %({
+            "@context": {"ex": "http://example.org/foo]"},
+            "ex:bar": "term"
+          })
+        },
+        "compacts using simple term ending in gen-delim ('@')" => {
+          input: %({"http://example.org/foo@bar": "term"}),
+          context: %({"ex": "http://example.org/foo@"}),
+          output: %({
+            "@context": {"ex": "http://example.org/foo@"},
+            "ex:bar": "term"
+          })
+        },
+      }.each do |title, params|
+        it(title) {run_compact(params)}
+      end
+    end
   end
 
   def run_compact(params)
-    input, output, context, processingMode = params[:input], params[:output], params[:context], params[:processingMode]
+    input, output, context = params[:input], params[:output], params[:context]
     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, processingMode: processingMode)}.to raise_error(params[:exception])
+      expect {JSON::LD::API.compact(input, context, params.merge(logger: logger))}.to raise_error(params[:exception])
     else
-      jld = JSON::LD::API.compact(input, context, logger: logger, processingMode: processingMode)
+      jld = JSON::LD::API.compact(input, context, params.merge(logger: logger))
       expect(jld).to produce(output, logger)
     end
   end

data/spec/context_spec.rb

@@ -24,7 +24,7 @@ end
 
 describe JSON::LD::Context do
   let(:logger) {RDF::Spec.logger}
-  let(:context) {JSON::LD::Context.new(logger: logger, validate: true, processingMode: "json-ld-1.1")}
+  let(:context) {JSON::LD::Context.new(logger: logger, validate: true, processingMode: "json-ld-1.1", compactToRelative: true)}
   let(:remote_doc) do
     JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({
       "@context": {
@@ -76,11 +76,11 @@ describe JSON::LD::Context do
           "avatar"   => "http://xmlns.com/foaf/0.1/avatar"
         }, logger)
       end
-      
+
       it "notes non-existing @context" do
         expect {subject.parse(StringIO.new("{}"))}.to raise_error(JSON::LD::JsonLdError::InvalidRemoteContext)
       end
-      
+
       it "parses a referenced context at a relative URI" do
         rd1 = JSON::LD::API::RemoteDocument.new("http://example.com/c1", %({"@context": "context"}))
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/c1", anything).and_yield(rd1)
@@ -302,7 +302,7 @@ describe JSON::LD::Context do
           expect(nil_ec.coercions).to eq init_ec.coercions
           expect(nil_ec.containers).to eq init_ec.containers
         end
-        
+
         it "removes a term definition" do
           expect(subject.parse({"name" => nil}).send(:mapping, "name")).to be_nil
         end
@@ -322,11 +322,14 @@ describe JSON::LD::Context do
         "@type as @list" => {"foo" => {"@type" => "@list"}},
         "@type as @set" => {"foo" => {"@type" => "@set"}},
         "@container as object" => {"foo" => {"@container" => {}}},
-        "@container as array" => {"foo" => {"@container" => []}},
+        "@container as empty array" => {"foo" => {"@container" => []}},
         "@container as string" => {"foo" => {"@container" => "true"}},
         "@context which is invalid" => {"foo" => {"@context" => {"bar" => []}}},
         "@language as @id" => {"@language" => {"@id" => "http://example.com/"}},
         "@vocab as @id" => {"@vocab" => {"@id" => "http://example.com/"}},
+        "@prefix string" => {"foo" => {"@id" => 'http://example.org/', "@prefix" => "str"}},
+        "@prefix array" => {"foo" => {"@id" => 'http://example.org/', "@prefix" => []}},
+        "@prefix object" => {"foo" => {"@id" => 'http://example.org/', "@prefix" => {}}},
       }.each do |title, context|
         it title do
           expect {
@@ -335,7 +338,25 @@ describe JSON::LD::Context do
           }.to raise_error(JSON::LD::JsonLdError)
         end
       end
-      
+
+      context "1.0" do
+        let(:context) {JSON::LD::Context.new(logger: logger, validate: true)}
+        {
+          "@context" => {"foo" => {"@id" => 'http://example.org/', "@context" => {}}},
+          "@container @id" => {"foo" => {"@container" => "@id"}},
+          "@container @type" => {"foo" => {"@container" => "@type"}},
+          "@nest" => {"foo" => {"@id" => 'http://example.org/', "@nest" => "@nest"}},
+          "@prefix" => {"foo" => {"@id" => 'http://example.org/', "@prefix" => true}},
+        }.each do |title, context|
+          it title do
+            expect {
+              ec = subject.parse(context)
+              expect(ec.serialize).to produce({}, logger)
+            }.to raise_error(JSON::LD::JsonLdError)
+          end
+        end
+      end
+
       (JSON::LD::KEYWORDS - %w(@base @language @vocab)).each do |kw|
         it "does not redefine #{kw} as a string" do
           expect {
@@ -807,7 +828,7 @@ describe JSON::LD::Context do
           end
         end
       end
-    
+
       context "@vocab" do
         {
           "absolute IRI" =>  ["http://example.org/", RDF::URI("http://example.org/")],
@@ -858,7 +879,7 @@ describe JSON::LD::Context do
       "unmapped"      => ["foo",                 "foo"],
       "bnode"         => ["_:a",                 RDF::Node("a")],
       "relative"      => ["foo/bar",             "http://base/foo/bar"],
-      "odd CURIE"     => ["exp:s",               "http://example.org/perts"]
+      "odd CURIE"     => ["ex:perts",            "http://example.org/perts"]
     }.each do |title, (result, input)|
       it title do
         expect(subject.compact_iri(input)).to produce(result, logger)
@@ -904,7 +925,7 @@ describe JSON::LD::Context do
         subject.set_mapping("name", "http://xmlns.com/foaf/0.1/name")
         subject.set_mapping("ex", nil)
         expect(subject.compact_iri("http://example.org/name", position: :predicate)).
-          to produce("lex:name", logger)
+          not_to produce("name", logger)
       end
     end
 
@@ -963,7 +984,7 @@ describe JSON::LD::Context do
             [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => true}],
             [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => 1}],
             [{"@value" => "de", "@language" => "de"}, {"@value" => "jp", "@language" => "jp"}],
-            [{"@value" => true}], [{"@value" => false}], 
+            [{"@value" => true}], [{"@value" => false}],
             [{"@value" => 1}], [{"@value" => 1.1}],
           ],
           "listlang" => [[{"@value" => "en", "@language" => "en"}]],
@@ -984,9 +1005,7 @@ describe JSON::LD::Context do
       end
     end
 
-    context "with :simple_compact_iris" do
-      before(:each) { subject.instance_variable_get(:@options)[:simple_compact_iris] = true}
-
+    context "CURIE compaction" do
       {
         "nil" => [nil, nil],
         "absolute IRI"  => ["http://example.com/", "http://example.com/"],
@@ -1223,7 +1242,7 @@ describe JSON::LD::Context do
         end
       end
     end
-    
+
     context "coercion" do
       before(:each) {subject.default_language = "en"}
       {

data/spec/expand_spec.rb

@@ -83,7 +83,16 @@ describe JSON::LD::API do
       "@value with false" => {
         input: {"http://example.com/ex" => {"@value" => false}},
         output: [{"http://example.com/ex" => [{"@value" => false}]}]
-      }
+      },
+      "compact IRI" => {
+        input: {
+          "@context" => {"ex" => "http://example.com/"},
+          "ex:p" => {"@id" => "ex:Sub1"}
+        },
+        output: [{
+          "http://example.com/p" => [{"@id" => "http://example.com/Sub1"}]
+        }]
+      },
     }.each_pair do |title, params|
       it(title) {run_expand params}
     end
@@ -1201,6 +1210,7 @@ describe JSON::LD::API do
             }
           }),
           processingMode: nil,
+          validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
       }.each do |title, params|
@@ -1323,6 +1333,7 @@ describe JSON::LD::API do
             }
           }),
           processingMode: nil,
+          validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
       }.each do |title, params|
@@ -1452,6 +1463,7 @@ describe JSON::LD::API do
             "a": {"@type": "Foo", "bar": "baz"}
           }),
           processingMode: nil,
+          validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
       }.each do |title, params|
@@ -1622,7 +1634,7 @@ describe JSON::LD::API do
     output = ::JSON.parse(output) if output.is_a?(String)
     pending params.fetch(:pending, "test implementation") unless input
     if params[:exception]
-      expect {JSON::LD::API.expand(input, processingMode: processingMode)}.to raise_error(params[:exception])
+      expect {JSON::LD::API.expand(input, {processingMode: processingMode}.merge(params))}.to raise_error(params[:exception])
     else
       jld = JSON::LD::API.expand(input, base: params[:base], logger: logger, processingMode: processingMode)
       expect(jld).to produce(output, logger)

data/spec/suite_helper.rb

@@ -108,7 +108,7 @@ module Fixtures
       def options
         @options ||= begin
           opts = {documentLoader: Fixtures::SuiteTest.method(:documentLoader)}
-          (property('option') || {}).each do |k, v|
+          {'specVersion' => "1.1"}.merge(property('option') || {}).each do |k, v|
             opts[k.to_sym] = v
           end
           opts
@@ -162,6 +162,11 @@ module Fixtures
         end
         options = {validate: true}.merge(options)
 
+        unless options[:specVersion] == "1.1"
+          skip "not a 1.1 test" 
+          return
+        end
+
         if positiveTest?
           logger.info "expected: #{expect rescue nil}" if expect_loc
           begin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 2.1.4
+  version: 2.1.5
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-02 00:00:00.000000000 Z
+date: 2017-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: jsonlint
   requirement: !ruby/object:Gem::Requirement
@@ -343,7 +343,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: json-ld
-rubygems_version: 2.6.11
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: JSON-LD reader/writer for Ruby.