json-ld 1.1.7 → 1.1.8

data/lib/json/ld/compact.rb

@@ -36,7 +36,7 @@ module JSON::LD
         return nil if element.has_key?('@null')
 
         if element.keys.any? {|k| %w(@id @value).include?(k)}
-          result = context.compact_value(property, element, :depth => @depth)
+          result = context.compact_value(property, element, depth: @depth)
           unless result.is_a?(Hash)
             debug("") {"=> scalar result: #{result.inspect}"}
             return result
@@ -52,11 +52,11 @@ module JSON::LD
 
           if %w(@id @type).include?(expanded_property)
             compacted_value = [expanded_value].flatten.compact.map do |expanded_type|
-              depth {context.compact_iri(expanded_type, :vocab => (expanded_property == '@type'), :depth => @depth)}
+              depth {context.compact_iri(expanded_type, vocab: (expanded_property == '@type'), depth: @depth)}
             end
             compacted_value = compacted_value.first if compacted_value.length == 1
 
-            al = context.compact_iri(expanded_property, :vocab => true, :quiet => true)
+            al = context.compact_iri(expanded_property, vocab: true, quiet: true)
             debug(expanded_property) {"result[#{al}] = #{compacted_value.inspect}"}
             result[al] = compacted_value
             next
@@ -76,7 +76,7 @@ module JSON::LD
             end
 
             unless compacted_value.empty?
-              al = context.compact_iri('@reverse', :quiet => true)
+              al = context.compact_iri('@reverse', quiet: true)
               debug("") {"remainder: #{al} => #{compacted_value.inspect}"}
               result[al] = compacted_value
             end
@@ -90,7 +90,7 @@ module JSON::LD
 
           # Otherwise, if expanded property is @index, @value, or @language:
           if %w(@index @value @language).include?(expanded_property)
-            al = context.compact_iri(expanded_property, :vocab => true, :quiet => true)
+            al = context.compact_iri(expanded_property, vocab: true, quiet: true)
             debug(expanded_property) {"#{al} => #{expanded_value.inspect}"}
             result[al] = expanded_value
             next
@@ -99,10 +99,10 @@ module JSON::LD
           if expanded_value == []
             item_active_property = depth do
               context.compact_iri(expanded_property,
-                                  :value => expanded_value,
-                                  :vocab => true,
-                                  :reverse => inside_reverse,
-                                  :depth => @depth)
+                                  value: expanded_value,
+                                  vocab: true,
+                                  reverse: inside_reverse,
+                                  depth: @depth)
             end
 
             iap = result[item_active_property] ||= []
@@ -113,10 +113,10 @@ module JSON::LD
           expanded_value.each do |expanded_item|
             item_active_property = depth do
               context.compact_iri(expanded_property,
-                                  :value => expanded_item,
-                                  :vocab => true,
-                                  :reverse => inside_reverse,
-                                  :depth => @depth)
+                                  value: expanded_item,
+                                  vocab: true,
+                                  reverse: inside_reverse,
+                                  depth: @depth)
             end
             container = context.container(item_active_property)
             value = list?(expanded_item) ? expanded_item['@list'] : expanded_item
@@ -126,10 +126,10 @@ module JSON::LD
             if list?(expanded_item)
               compacted_item = [compacted_item] unless compacted_item.is_a?(Array)
               unless container == '@list'
-                al = context.compact_iri('@list', :vocab => true, :quiet => true)
+                al = context.compact_iri('@list', vocab: true, quiet: true)
                 compacted_item = {al => compacted_item}
                 if expanded_item.has_key?('@index')
-                  key = context.compact_iri('@index', :vocab => true, :quiet => true)
+                  key = context.compact_iri('@index', vocab: true, quiet: true)
                   compacted_item[key] = expanded_item['@index']
                 end
               else

data/lib/json/ld/context.rb

@@ -1,4 +1,3 @@
-require 'open-uri'
 require 'json'
 require 'bigdecimal'
 
@@ -107,7 +106,6 @@ module JSON::LD
     attr_accessor :context_base
 
     # Term definitions
-    # @!attribute [r] term_definitions
     # @return [Hash{String => TermDefinition}]
     attr_reader :term_definitions
 
@@ -118,7 +116,6 @@ module JSON::LD
     #
     #
     # This adds a language to plain strings that aren't otherwise coerced
-    # @!attribute [rw] default_language
     # @return [String]
     attr_reader :default_language
     
@@ -135,7 +132,6 @@ module JSON::LD
     # @return [Context] A context provided to us that we can use without re-serializing XXX
     attr_accessor :provided_context
 
-    # @!attribute [r] namer
     # @return [BlankNodeNamer]
     attr_accessor :namer
 
@@ -206,7 +202,7 @@ module JSON::LD
         @base.canonicalize!
         @base.fragment = nil
         @base.query = nil
-        raise JsonLdError::InvalidBaseIRI, "@base must be an absolute IRI: #{value.inspect}" unless @base.absolute?
+        raise JsonLdError::InvalidBaseIRI, "@base must be an absolute IRI: #{value.inspect}" unless @base.absolute? || !@options[:validate]
         @base
       else
         @base = nil
@@ -231,7 +227,7 @@ module JSON::LD
         value
       when String
         v = as_resource(value)
-        raise JsonLdError::InvalidVocabMapping, "@value must be an absolute IRI: #{value.inspect}" if v.uri? && v.relative?
+        raise JsonLdError::InvalidVocabMapping, "@value must be an absolute IRI: #{value.inspect}" if v.uri? && v.relative? && @options[:validate]
         v
       when nil
         nil
@@ -296,7 +292,9 @@ module JSON::LD
             context_no_base.context_base = context.to_s
 
             begin
-              @options[:documentLoader].call(context.to_s) do |remote_doc|
+              context_opts = @options.dup
+              context_opts.delete(:headers)
+              @options[:documentLoader].call(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.
                 jo = case remote_doc.document
                 when String then JSON.parse(remote_doc.document)
@@ -353,6 +351,33 @@ module JSON::LD
       result
     end
 
+    ##
+    # Merge in a context, creating a new context with updates from `context`
+    #
+    # @param [Context] context
+    # @return [Context]
+    def merge(context)
+      c = self.dup.merge!(context)
+      c.instance_variable_set(:@term_definitions, context.term_definitions.dup)
+      c
+    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)
+      self
+    end
+
     ##
     # Create Term Definition
     #
@@ -415,7 +440,7 @@ module JSON::LD
             type
           when String
             begin
-              expand_iri(type, :vocab => true, :documentRelative => false, :local_context => local_context, :defined => defined)
+              expand_iri(type, vocab: true, documentRelative: false, local_context: local_context, defined: defined)
             rescue JsonLdError::InvalidIRIMapping
               raise JsonLdError::InvalidTypeMapping, "invalid mapping for '@type': #{type.inspect} on term #{term.inspect}"
             end
@@ -437,10 +462,10 @@ module JSON::LD
 
           # Otherwise, set the IRI mapping of definition to the result of using the IRI Expansion algorithm, passing active context, the value associated with the @reverse key for value, true for vocab, true for document relative, local context, and defined. If the result is not an absolute IRI, i.e., it contains no colon (:), an invalid IRI mapping error has been detected and processing is aborted.
           definition.id =  expand_iri(value['@reverse'],
-                                      :vocab => true,
-                                      :documentRelative => true,
-                                      :local_context => local_context,
-                                      :defined => defined)
+                                      vocab: true,
+                                      documentRelative: true,
+                                      local_context: local_context,
+                                      defined: defined)
           raise JsonLdError::InvalidIRIMapping, "non-absolute @reverse IRI: #{definition.id} on term #{term.inspect}" unless
             definition.id.is_a?(RDF::URI) && definition.id.absolute?
 
@@ -456,10 +481,10 @@ module JSON::LD
           raise JsonLdError::InvalidIRIMapping, "expected value of @id to be a string: #{value['@id'].inspect} on term #{term.inspect}" unless
             value['@id'].is_a?(String)
           definition.id = expand_iri(value['@id'],
-            :vocab => true,
-            :documentRelative => true,
-            :local_context => local_context,
-            :defined => defined)
+            vocab: true,
+            documentRelative: true,
+            local_context: local_context,
+            defined: defined)
           raise JsonLdError::InvalidKeywordAlias, "expected value of @id to not be @context on term #{term.inspect}" if
             definition.id == '@context'
         elsif term.include?(':')
@@ -877,7 +902,7 @@ module JSON::LD
           preferred_values = []
           preferred_values << '@reverse' if tl_value == '@reverse'
           if %w(@id @reverse).include?(tl_value) && value.is_a?(Hash) && value.has_key?('@id')
-            t_iri = compact_iri(value['@id'], :vocab => true, :document_relative => true)
+            t_iri = compact_iri(value['@id'], vocab: true, document_relative: true)
             if (r_td = term_definitions[t_iri]) && r_td.id == value['@id']
               preferred_values.concat(%w(@vocab @id @none))
             else
@@ -965,20 +990,20 @@ module JSON::LD
     # @raise [RDF::ReaderError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-expansion
     def expand_value(property, value, options = {})
-      options = {:useNativeTypes => false}.merge(options)
+      options = {useNativeTypes: false}.merge(options)
       depth(options) do
         debug("expand_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
         # If the active property has a type mapping in active context that is @id, return a new JSON object containing a single key-value pair where the key is @id and the value is the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
         if (td = term_definitions.fetch(property, TermDefinition.new(property))) && td.type_mapping == '@id'
           debug("") {"as relative IRI: #{value.inspect}"}
-          return {'@id' => expand_iri(value, :documentRelative => true).to_s}
+          return {'@id' => expand_iri(value, documentRelative: true).to_s}
         end
 
         # If active property has a type mapping in active context that is @vocab, return a new JSON object containing a single key-value pair where the key is @id and the value is the result of using the IRI Expansion algorithm, passing active context, value, true for vocab, and true for document relative.
         if td.type_mapping == '@vocab'
           debug("") {"as vocab IRI: #{value.inspect}"}
-          return {'@id' => expand_iri(value, :vocab => true, :documentRelative => true).to_s}
+          return {'@id' => expand_iri(value, vocab: true, documentRelative: true).to_s}
         end
 
         value = RDF::Literal(value) if
@@ -1063,12 +1088,12 @@ module JSON::LD
         when coerce(property) == '@vocab' && value.has_key?('@id') && num_members == 1
           # Compact an @id coercion
           debug("") {" (@id & coerce & vocab)"}
-          compact_iri(value['@id'], :vocab => true)
+          compact_iri(value['@id'], vocab: true)
         when value.has_key?('@id')
           debug("") {" (@id)"}
           # return value as is
           value
-        when value['@type'] && expand_iri(value['@type'], :vocab => true) == coerce(property)
+        when value['@type'] && expand_iri(value['@type'], vocab: true) == coerce(property)
           # Compact common datatype
           debug("") {" (@type & coerce) == #{coerce(property)}"}
           value['@value']

data/lib/json/ld/expand.rb

@@ -15,7 +15,7 @@ module JSON::LD
     #   Ensure output objects have keys ordered properly
     # @return [Array, Hash]
     def expand(input, active_property, context, options = {})
-      options = {:ordered => true}.merge(options)
+      options = {ordered: true}.merge(options)
       debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       result = case input
       when Array
@@ -49,7 +49,7 @@ module JSON::LD
           keys.each do |key|
             # For each key and value in element, ordered lexicographically by key:
             value = input[key]
-            expanded_property = context.expand_iri(key, :vocab => true, :depth => @depth)
+            expanded_property = context.expand_iri(key, vocab: true, depth: @depth)
 
             # If expanded property is null or it neither contains a colon (:) nor it is a keyword, drop key by continuing to the next key.
             next if expanded_property.is_a?(RDF::URI) && expanded_property.relative?
@@ -78,7 +78,7 @@ module JSON::LD
                       "value of @id must be a string: #{value.inspect}" unless value.is_a?(String)
 
                 # Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
-                context.expand_iri(value, :documentRelative => true, :depth => @depth).to_s
+                context.expand_iri(value, documentRelative: true, depth: @depth).to_s
               when '@type'
                 # If expanded property is @type and value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, true for vocab, and true for document relative to expand the value or each of its items.
                 debug("@type") {"value: #{value.inspect}"}
@@ -88,11 +88,11 @@ module JSON::LD
                     value.map do |v|
                       raise JsonLdError::InvalidTypeValue,
                             "@type value must be a string or array of strings: #{v.inspect}" unless v.is_a?(String)
-                      context.expand_iri(v, :vocab => true, :documentRelative => true, :quiet => true, :depth => @depth).to_s
+                      context.expand_iri(v, vocab: true, documentRelative: true, quiet: true, depth: @depth).to_s
                     end
                   end
                 when String
-                  context.expand_iri(value, :vocab => true, :documentRelative => true, :quiet => true, :depth => @depth).to_s
+                  context.expand_iri(value, vocab: true, documentRelative: true, quiet: true, depth: @depth).to_s
                 when Hash
                   # For framing
                   raise JsonLdError::InvalidTypeValue,
@@ -298,7 +298,7 @@ module JSON::LD
               raise JsonLdError::InvalidLanguageTaggedValue,
                     "when @language is used, @value must be a string: #{@value.inspect}"
             elsif !output_object.fetch('@type', "").is_a?(String) ||
-                  !context.expand_iri(output_object.fetch('@type', ""), :vocab => true, :depth => @depth).is_a?(RDF::URI)
+                  !context.expand_iri(output_object.fetch('@type', ""), vocab: true, depth: @depth).is_a?(RDF::URI)
               # Otherwise, if the result has a @type member and its value is not an IRI, an invalid typed value error has been detected and processing is aborted.
               raise JsonLdError::InvalidTypedValue,
                     "value of @type must be an IRI: #{output_object['@type'].inspect}"
@@ -338,7 +338,7 @@ module JSON::LD
       else
         # Otherwise, unless the value is a number, expand the value according to the Value Expansion rules, passing active property.
         return nil if input.nil? || active_property.nil? || active_property == '@graph'
-        context.expand_value(active_property, input, :depth => @depth)
+        context.expand_value(active_property, input, depth: @depth)
       end
 
       debug {" => #{result.inspect}"}

data/lib/json/ld/extensions.rb

@@ -16,7 +16,7 @@ module RDF
       @properties.delete(subject.to_s) if recalc
       @properties[subject.to_s] ||= begin
         hash = Hash.new
-        self.query(:subject => subject) do |statement|
+        self.query(subject: subject) do |statement|
           pred = statement.predicate.to_s
 
           hash[pred] ||= []
@@ -28,7 +28,7 @@ module RDF
 
     # Get type(s) of subject, returns a list of symbols
     def type_of(subject)
-      query(:subject => subject, :predicate => RDF.type).map {|st| st.object}
+      query(subject: subject, predicate: RDF.type).map {|st| st.object}
     end
   end
   

data/lib/json/ld/flatten.rb

@@ -167,7 +167,7 @@ module JSON::LD
           end
         end
 
-        debug("node_map") {node_map.to_json(JSON_STATE)}
+        debug("node_map") {node_map.to_json(JSON_STATE) rescue 'malformed json'}
       end
     end
   end

data/lib/json/ld/format.rb

@@ -9,21 +9,21 @@ module JSON::LD
   #     RDF::Format.for("etc/foaf.ld")
   #     RDF::Format.for(:file_name      => "etc/foaf.json")
   #     RDF::Format.for(:file_name      => "etc/foaf.ld")
-  #     RDF::Format.for(:file_extension => "json")
-  #     RDF::Format.for(:file_extension => "ld")
+  #     RDF::Format.for(file_extension: "json")
+  #     RDF::Format.for(file_extension: "ld")
   #     RDF::Format.for(:content_type   => "application/json")
   #
   # @example Obtaining serialization format MIME types
   #     RDF::Format.content_types      #=> {"application/json" => [JSON::LD::Format]}
   #
   # @example Obtaining serialization format file extension mappings
-  #     RDF::Format.file_extensions    #=> {:json => "application/json"}
+  #     RDF::Format.file_extensions    #=> {json: "application/json"}
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
     content_type     'application/ld+json',
-                     :extension => :jsonld,
-                     :alias => 'application/x-ld+json'
+                     extension: :jsonld,
+                     alias: 'application/x-ld+json'
     content_encoding 'utf-8'
 
     reader { JSON::LD::Reader }

data/lib/json/ld/frame.rb

@@ -21,8 +21,8 @@ module JSON::LD
         parent, property = options[:parent], options[:property]
         debug("frame") {"state: #{state.inspect}"}
         debug("frame") {"nodes: #{nodes.keys.inspect}"}
-        debug("frame") {"frame: #{frame.to_json(JSON_STATE)}"}
-        debug("frame") {"parent: #{parent.to_json(JSON_STATE)}"}
+        debug("frame") {"frame: #{frame.to_json(JSON_STATE) rescue 'malformed json'}"}
+        debug("frame") {"parent: #{parent.to_json(JSON_STATE) rescue 'malformed json'}"}
         debug("frame") {"property: #{property.inspect}"}
         # Validate the frame
         validate_frame(state, frame)
@@ -41,12 +41,12 @@ module JSON::LD
         matches.keys.kw_sort.each do |id|
           element = matches[id]
           # If the active property is null, set the map of embeds in state to an empty map
-          state = state.merge(:embeds => {}) if property.nil?
+          state = state.merge(embeds: {}) if property.nil?
 
           output = {'@id' => id}
         
           # prepare embed meta info
-          embedded_node = {:parent => parent, :property => property}
+          embedded_node = {parent: parent, property: property}
         
           # If embedOn is true, and id is in map of embeds from state
           if embed && (existing = state[:embeds].fetch(id, nil))
@@ -340,7 +340,7 @@ module JSON::LD
           unless state[:embeds].has_key?(sid)
             debug("frame") {"embed element #{sid.inspect}"}
             # Embed full element, if it isn't already embedded
-            embed = {:parent => output, :property => property}
+            embed = {parent: output, property: property}
             state[:embeds][sid] = embed
           
             # Recurse into element

data/lib/json/ld/from_rdf.rb

@@ -71,7 +71,7 @@ module JSON::LD
           list, list_nodes = [], []
 
           # If property equals rdf:rest, the value associated to the usages member of node has exactly 1 entry, node has a rdf:first and rdf:rest property, both of which have as value an array consisting of a single element, and node has no other members apart from an optional @type member whose value is an array with a single item equal to rdf:List, node represents a well-formed list node. Continue with the following steps:
-          debug("list element?") {node.to_json(JSON_STATE)}
+          debug("list element?") {node.to_json(JSON_STATE) rescue 'malformed json'}
           while property == RDF.rest.to_s &&
               node_usages_map[node['@id']].uniq.length == 1 &&
               blank_node?(node) &&
@@ -118,7 +118,7 @@ module JSON::LD
         node.delete(:usages)
         result << node unless node_reference?(node)
       end
-      debug("fromRdf") {result.to_json(JSON_STATE)}
+      debug("fromRdf") {result.to_json(JSON_STATE) rescue 'malformed json'}
       result
     end
   end

data/lib/json/ld/reader.rb

@@ -1,5 +1,3 @@
-require 'open-uri'
-
 module JSON::LD
   ##
   # A JSON-LD parser in Ruby.

data/lib/json/ld/resource.rb

@@ -128,7 +128,7 @@ module JSON::LD
       end
 
       compacted = nil
-      JSON::LD::API.expand(node_definition, :expandContext => @context) do |expanded|
+      JSON::LD::API.expand(node_definition, expandContext: @context) do |expanded|
         compacted = JSON::LD::API.compact(expanded, @context)
       end
       compacted.delete_if {|k, v| k == '@context'}
@@ -169,9 +169,9 @@ module JSON::LD
         when Hash
           if node_reference?(obj)
             reference_map[obj['id']] ||= Resource.new(obj,
-              :context => @context_name,
-              :clean => false,
-              :stub => true
+              context: @context_name,
+              clean: false,
+              stub: true
               )
           else
             obj.keys.each do |k|