json-ld 1.0.1.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 97a3575f2cb93a3349fbf649fbe3f6e2bc76f309
-  data.tar.gz: 03bd6138b0f58510bf04e80cd0b303c0672ac30e
-SHA512:
-  metadata.gz: 31a098c284a903bcc42447954a9989e3d775d10c88dd91abdfd02c6c04e8714e6e0d81ac9daa01db96abb58b3acadc185da3331fee040aad9055c11e2d25b8f4
-  data.tar.gz: 5aa36012fdc65dce8d9129cff315b6ed828e3a8be3af7c4d093fe5becc100360c90ad0bd8e9bc1b30230c5ece62952dc339541485403a705cfaf071f7926b543
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzllY2IzN2M4MjQ5MGUxMWQ0M2NhYTliZWFmMzUyYzZmMDYwODIxOQ==
+  data.tar.gz: !binary |-
+    OGM3NmQ5YTVhMDk3ZTE3NGZjNmM4MTc2NWQ0Y2NiNzhlZjllOWMxYw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZjkxY2E1ZGZiZDM2M2EyMDUwMTFmZGIwNmI2YTYyMGRkYzI5YzQ4OTRkMTFm
+    N2VlZjE5OGEzN2FiMTcyY2U4MGVkOGMzN2RhOWIyZmQ2MTczMDNhMjI5NDli
+    MTBmZTJkOWEzZWYzZjE0Mjk5Mjc1YzgwOTA3YzFlZGZmZWVmYTI=
+  data.tar.gz: !binary |-
+    NzNmZTU0YTA3OGQ0MmRjZjNlNzhlNzlkNzFlNDQ2OWY4YWM5MTIyNjA1MzFl
+    MTYxNjZiMzFhZWIzNWNhM2I1YjE3ZDA4NDc4M2EwOGI0YjJkYzNkOTJlNDk0
+    ZTliMTMwNDk5MWZmOGU2NjQ3NDFmYjkyMTE3NTRhN2NkYzVkYzk=

data/README.md

@@ -184,7 +184,7 @@ Install with `gem install json-ld`
       }
     }
 
-    JSON::LD::fromRDF(input, context) =>
+    JSON::LD::API::fromRDF(input, context) =>
     {
       "@context": {
         "":       "http://manu.sporny.org/",
@@ -206,7 +206,7 @@ Install with `gem install json-ld`
     graph.dump(:jsonld, :standard_prefixes => true)
 
 ## Documentation
-Full documentation available on [RubyDoc](http://rubydoc.info/gems/json-ld/file/README.markdown)
+Full documentation available on [RubyDoc](http://rubydoc.info/gems/json-ld/file/README.md)
 
 ## Differences from [JSON-LD API][]
 The specified JSON-LD API is based on a WebIDL definition intended for use within the browser.

data/VERSION

@@ -1 +1 @@
-1.0.1.1
+1.0.3

data/lib/json/ld/api.rb

@@ -26,7 +26,7 @@ module JSON::LD
 
     # Options used for open_file
     OPEN_OPTS = {
-      :headers => %w(Accept: application/ld+json, application/json)
+      :headers => {"Accept" => "application/ld+json, application/json"}
     }
 
     # Current input
@@ -212,11 +212,11 @@ module JSON::LD
           entry = default_graph[graph_name] ||= {'@id' => graph_name}
           nodes = entry['@graph'] ||= []
           graph.keys.kw_sort.each do |id|
-            nodes << graph[id]
+            nodes << graph[id] unless node_reference?(graph[id])
           end
         end
         default_graph.keys.kw_sort.each do |id|
-          flattened << default_graph[id]
+          flattened << default_graph[id] unless node_reference?(default_graph[id])
         end
 
         if context && !flattened.empty?
@@ -302,10 +302,10 @@ module JSON::LD
         all_nodes = Hash.ordered
         old_dbg, @options[:debug] = @options[:debug], nil
         depth do
-          generate_node_map(value, all_nodes, '@merged')
+          generate_node_map(value, all_nodes)
         end
         @options[:debug] = old_dbg
-        @node_map = all_nodes['@merged']
+        @node_map = all_nodes['@default']
         debug(".frame") {"node_map: #{@node_map.to_json(JSON_STATE)}"}
 
         result = []
@@ -339,6 +339,8 @@ module JSON::LD
     # @param [{Symbol,String => Object}] options
     #   See options in {JSON::LD::API#initialize}
     #   Options passed to {JSON::LD::API.expand}
+    # @option options [Boolean] :produceGeneralizedRDF (false)
+    #   If true, output will include statements having blank node predicates, otherwise they are dropped.
     # @raise [InvalidContext]
     # @return [Array<RDF::Statement>] if no block given
     # @yield statement
@@ -366,6 +368,7 @@ module JSON::LD
           context = as_resource(graph_name) unless graph_name == '@default'
           debug(".toRDF") {"context: #{context ? context.to_ntriples : 'null'}"}
           graph_to_rdf(graph).each do |statement|
+            next if statement.predicate.node? && !options[:produceGeneralizedRDF]
             statement.context = context if context
             if block_given?
               yield statement

data/lib/json/ld/compact.rb

@@ -67,7 +67,8 @@ module JSON::LD
             debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
             compacted_value.each do |prop, value|
               if context.reverse?(prop)
-                value = [value] unless value.is_a?(Array) || @options[:compactArrays]
+                value = [value] if !value.is_a?(Array) &&
+                  (context.container(prop) == '@set' || !@options[:compactArrays])
                 debug("") {"merge #{prop} => #{value.inspect}"}
                 merge_compacted_value(result, prop, value)
                 compacted_value.delete(prop)

data/lib/json/ld/context.rb

@@ -46,7 +46,7 @@ module JSON::LD
            cid = context.compact_iri(id)
            cid == term ? id : cid
         else
-          defn = Hash.ordered
+          defn = {}
           cid = context.compact_iri(id)
           defn[reverse_property ? '@reverse' : '@id'] = cid unless cid == term && !reverse_property
           if type_mapping
@@ -76,9 +76,14 @@ module JSON::LD
 
     # The base.
     #
-    # @return [RDF::URI] Document base IRI, used for expanding relative IRIs.
+    # @return [RDF::URI] Current base IRI, used for expanding relative IRIs.
     attr_reader :base
 
+    # The base.
+    #
+    # @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
     attr_accessor :context_base
 
@@ -126,7 +131,7 @@ module JSON::LD
     # @return [Context]
     def initialize(options = {})
       if options[:base]
-        @doc_base = RDF::URI(options[:base])
+        @base = @doc_base = RDF::URI(options[:base])
         @doc_base.canonicalize!
         @doc_base.fragment = nil
         @doc_base.query = nil
@@ -179,13 +184,17 @@ module JSON::LD
 
     # @param [String] value must be an absolute IRI
     def vocab=(value)
-      if value
-        raise InvalidContext::InvalidVocabMapping, "@value must be a string: #{value.inspect}" unless value.is_a?(String)
-        @vocab = RDF::URI(value)
-        raise InvalidContext::InvalidVocabMapping, "@value must be an absolute IRI: #{value.inspect}" unless @vocab.absolute?
-        @vocab
+      @vocab = case value
+      when /_:/
+        value
+      when String
+        v = as_resource(value)
+        raise InvalidContext::InvalidVocabMapping, "@value must be an absolute IRI: #{value.inspect}" if v.uri? && v.relative?
+        v
+      when nil
+        nil
       else
-        @vocab = nil
+        raise InvalidContext::InvalidVocabMapping, "@value must be a string: #{value.inspect}"
       end
     end
 
@@ -234,7 +243,7 @@ module JSON::LD
             # Load context document, if it is a string
             begin
               # 3.2.1) Set context to the result of resolving value against the base IRI which is established as specified in section 5.1 Establishing a Base URI of [RFC3986]. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [RFC3987].
-              context = RDF::URI(result.context_base || result.base || @doc_base).join(context)
+              context = RDF::URI(result.context_base || result.base).join(context)
 
               raise InvalidContext::RecursiveContextInclusion, "#{context}" if remote_contexts.include?(context)
               @remote_contexts = @remote_contexts + [context]
@@ -344,9 +353,18 @@ module JSON::LD
         debug("") {"Hash[#{term.inspect}] = #{value.inspect}"}
         definition = TermDefinition.new(term)
 
+        if value.has_key?('@type')
+          type = value['@type']
+          # SPEC FIXME: @type may be nil
+          raise InvalidContext::InvalidTypeMapping, "unknown mapping for '@type' to #{type.inspect}" unless type.is_a?(String) || type.nil?
+          type = expand_iri(type, :vocab => true, :documentRelative => true, :local_context => local_context, :defined => defined) if type.is_a?(String)
+          debug("") {"type_mapping: #{type.inspect}"}
+          definition.type_mapping = type
+        end
+
         if value.has_key?('@reverse')
           raise InvalidContext::InvalidReverseProperty, "unexpected key in #{value.inspect}" if
-            value.keys.any? {|k| ['@id', '@type', '@language'].include?(k)}
+            value.keys.any? {|k| %w(@id).include?(k)}
           raise InvalidContext::InvalidIRIMapping, "expected value of @reverse to be a string" unless
             value['@reverse'].is_a?(String)
 
@@ -358,11 +376,13 @@ module JSON::LD
                                       :defined => defined)
           raise InvalidContext::InvalidIRImapping, "non-absolute @reverse IRI: #{definition.id}" unless
             definition.id.absolute?
-          definition.type_mapping = '@id'
 
-          # If value contains an @container member, set the container mapping of definition to @index if that is the value of the @container member; otherwise an invalid reverse property error has been detected (reverse properties only support index-containers) and processing is aborted.
-          if (container = value['@container']) && container != '@index'
-            raise InvalidContext::InvalidReverseProperty, "unknown mapping for '@container' to #{container.inspect}"
+          # If value contains an @container member, set the container mapping of definition to its value; if its value is neither @set, nor @index, nor null, an invalid reverse property error has been detected (reverse properties only support set- and index-containers) and processing is aborted.
+          if (container = value['@container'])
+            raise InvalidContext::InvalidReverseProperty,
+                  "unknown mapping for '@container' to #{container.inspect}" unless
+                   ['@set', '@index', nil].include?(container)
+            definition.container_mapping = container
           end
           definition.reverse_property = true
         elsif value.has_key?('@id') && value['@id'] != term
@@ -393,15 +413,6 @@ module JSON::LD
           debug("") {"=> #{definition.id}"}
         end
 
-        if value.has_key?('@type')
-          type = value['@type']
-          # SPEC FIXME: @type may be nil
-          raise InvalidContext::InvalidTypeMapping, "unknown mapping for '@type' to #{type.inspect}" unless type.is_a?(String) || type.nil?
-          type = expand_iri(type, :vocab => true, :documentRelative => true, :local_context => local_context, :defined => defined) if type.is_a?(String)
-          debug("") {"type_mapping: #{type.inspect}"}
-          definition.type_mapping = type
-        end
-
         if value.has_key?('@container')
           container = value['@container']
           raise InvalidContext::InvalidContainerMapping, "unknown mapping for '@container' to #{container.inspect}" unless %w(@list @set @language @index).include?(container)
@@ -445,8 +456,8 @@ module JSON::LD
         else
           debug("serlialize: generate context")
           debug("") {"=> context: #{inspect}"}
-          ctx = Hash.ordered
-          ctx['@base'] = base.to_s if base
+          ctx = {}
+          ctx['@base'] = base.to_s if base && base != doc_base
           ctx['@language'] = default_language.to_s if default_language
           ctx['@vocab'] = vocab.to_s if vocab
 
@@ -460,7 +471,7 @@ module JSON::LD
         end
 
         # Return hash with @context, or empty
-        r = Hash.ordered
+        r = {}
         r['@context'] = use_context unless use_context.nil? || use_context.empty?
         r
       end
@@ -652,9 +663,9 @@ module JSON::LD
         result = if options[:vocab] && vocab
           # If vocab is true, and active context has a vocabulary mapping, return the result of concatenating the vocabulary mapping with value.
           vocab + value
-        elsif options[:documentRelative] && base = options.fetch(:base, self.base || @doc_base)
+        elsif options[:documentRelative] && base = options.fetch(:base, self.base)
           # Otherwise, if document relative is true, set value to the result of resolving value against the base IRI. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [RFC3987].
-          RDF::URI(base).join(value).to_s
+          RDF::URI(base).join(value)
         elsif local_context && RDF::URI(value).relative?
           # If local context is not null and value is not an absolute IRI, an invalid IRI mapping error has been detected and processing is aborted.
           raise JSON::LD::InvalidContext::InvalidIRIMapping, "not an absolute IRI: #{value}"
@@ -870,7 +881,7 @@ module JSON::LD
           {'@id' => value.to_s}
         when RDF::Literal
           debug("Literal") {"datatype: #{value.datatype.inspect}"}
-          res = Hash.ordered
+          res = {}
           if options[:useNativeTypes] && [RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double].include?(value.datatype)
             res['@value'] = value.object
             res['@type'] = uri(coerce(property)) if coerce(property)
@@ -1116,14 +1127,14 @@ module JSON::LD
     # @return [String]
     #   the relative IRI if relative to base, otherwise the absolute IRI.
     def remove_base(iri)
-      return iri unless base || @doc_base
+      return iri unless base
       @base_and_parents ||= begin
-        u = base || @doc_base
+        u = base
         iri_set = u.to_s.end_with?('/') ? [u.to_s] : []
         iri_set << u.to_s while (u = u.parent)
         iri_set
       end
-      b = (base || @doc_base).to_s
+      b = base.to_s
       return iri[b.length..-1] if iri.start_with?(b) && %w(? #).include?(iri[b.length, 1])
 
       @base_and_parents.each_with_index do |b, index|

data/lib/json/ld/expand.rb

@@ -81,7 +81,7 @@ module JSON::LD
                 case value
                 when Array
                   depth do
-                    [value].flatten.map do |v|
+                    value.map do |v|
                       raise ProcessingError::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

data/lib/json/ld/flatten.rb

@@ -10,11 +10,13 @@ module JSON::LD
     # @param [Hash{String => Hash}] node_map
     #   map of nodes
     # @param [String] active_graph
-    #   Graph name for results
+    #   The name of the currently active graph that the processor should use when processing.
+    # @param [String] active_subject
+    #   The currently active subject that the processor should use when processing.
+    # @param [String] active_property
+    #   The currently active property or keyword that the processor should use when processing.
     # @param [Array] list
     #   List for saving list elements
-    # @param [String] id (nil)
-    #   Identifier already associated with element
     def generate_node_map(element,
                           node_map,
                           active_graph    = '@default',
@@ -42,13 +44,9 @@ module JSON::LD
 
           # If element has an @type member, perform for each item the following steps:
           if element.has_key?('@type')
-            types = [element['@type']].flatten.map do |item|
+            types = Array(element['@type']).map do |item|
               # If item is a blank node identifier, replace it with a newly generated blank node identifier passing item for identifier.
-              item = namer.get_name(item) if blank_node?(item)
-
-              # If graph has no member item, create it and initialize its value to a JSON object consisting of a single member @id with the value item.
-              graph[item] ||= {'@id' => item}
-              item
+              blank_node?(item) ? namer.get_name(item) : item
             end
 
             element['@type'] = element['@type'].is_a?(Array) ? types : types.first
@@ -81,7 +79,7 @@ module JSON::LD
             merge_value(node, active_property, result)
           else
             # Otherwise element is a node object, perform the following steps:
-          
+
             # If element has an @id member, set id to its value and remove the member from element. If id is a blank node identifier, replace it with a newly generated blank node identifier passing id for identifier.
             # Otherwise, set id to the result of the Generate Blank Node Identifier algorithm passing null for identifier.
             id = element.delete('@id')
@@ -109,7 +107,7 @@ module JSON::LD
 
             # If element has an @type key, append each item of its associated array to the array associated with the @type key of node unless it is already in that array. Finally remove the @type member from element.
             if element.has_key?('@type')
-              [element.delete('@type')].flatten.each do |t|
+              Array(element.delete('@type')).each do |t|
                 merge_value(node, '@type', t)
               end
             end

data/lib/json/ld/from_rdf.rb

@@ -32,9 +32,9 @@ module JSON::LD
         subject = ec.expand_iri(statement.subject).to_s
         node = node_map[subject] ||= {'@id' => subject}
 
-        # If object is an IRI or blank node identifier, does not equal rdf:nil, and node map does not have an object member, create one and initialize its value to a new JSON object consisting of a single member @id whose value is set to object.
+        # If object is an IRI or blank node identifier, and node map does not have an object member, create one and initialize its value to a new JSON object consisting of a single member @id whose value is set to object.
         node_map[statement.object.to_s] ||= {'@id' => statement.object.to_s} unless
-        statement.object.literal? || statement.object == RDF.nil
+          statement.object.literal?
 
         # If predicate equals rdf:type, and object is an IRI or blank node identifier, append object to the value of the @type member of node. If no such member exists, create one and initialize it to an array whose only item is object. Finally, continue to the next RDF triple.
         if statement.predicate == RDF.type && statement.object.resource?
@@ -42,61 +42,64 @@ module JSON::LD
           next
         end
 
-        # If object equals rdf:nil and predicate does not equal rdf:rest, set value to a new JSON object consisting of a single member @list whose value is set to an empty array.
-        value = if statement.object == RDF.nil && statement.predicate != RDF.rest
-          {'@list' => []}
-        else
-          ec.expand_value(nil, statement.object, @options)
-        end
+        # Set value to the result of using the RDF to Object Conversion algorithm, passing object and use native types.
+        value = ec.expand_value(nil, statement.object, @options)
 
         merge_value(node, statement.predicate.to_s, value)
 
-        # If object is a blank node identifier and predicate equals neither rdf:first nor rdf:rest, it might represent the head of a RDF list:
-        if statement.object.node? && ![RDF.first, RDF.rest].include?(statement.predicate)
-          merge_value(node_map[statement.object.to_s], :usages, value)
+        # If object is a blank node identifier or IRI, it might represent the a list node:
+        if statement.object.resource?
+          # Append a new JSON object consisting of three members, node, property, and value to the usages array. The node member is set to a reference to node, property to predicate, and value to a reference to value.
+          merge_value(node_map[statement.object.to_s], :usages, {
+            :node => node,
+            :property => statement.predicate.to_s,
+            :value => value})
         end
       end
 
       # For each name and graph object in graph map:
       graph_map.each do |name, graph_object|
-        subjects = graph_object.keys
-        subjects.each do |subj|
-          next unless graph_object.has_key?(subj)
-          node = graph_object[subj]
-          next unless node[:usages].is_a?(Array) && node[:usages].length == 1
-          debug("list head") {node.to_json(JSON_STATE)}
-          value = node[:usages].first
-          list, list_nodes, subject = [], [], subj
-
-          while subject != RDF.nil.to_s && list
-            if node.nil? ||
-               !blank_node?(node) ||
-               node.keys.any? {|k| !["@id", :usages, RDF.first.to_s, RDF.rest.to_s].include?(k)} ||
-               !(f = node[RDF.first.to_s]).is_a?(Array) || f.length != 1 ||
-               !(r = node[RDF.rest.to_s]).is_a?(Array) || r.length != 1 || !node_reference?(r.first) ||
-               list_nodes.include?(subject)
-
-              debug("list") {"not valid list element: #{node.to_json(JSON_STATE)}"}
-              list = nil
-            else
-              list << f.first
-              list_nodes << node['@id']
-              subject = r.first['@id']
-              node = graph_object[subject]
-              debug("list") {"rest: #{node.to_json(JSON_STATE)}"}
-              list = nil if list_nodes.include?(subject)
-            end
+        next unless nil_var = graph_object[RDF.nil.to_s]
+
+        # For each item usage in the usages member of nil, perform the following steps:
+        nil_var[:usages].each do |usage|
+          node, property, head = usage[:node], usage[:property], usage[:value]
+          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)}
+          while property == RDF.rest.to_s &&
+              blank_node?(node) &&
+              node.keys.none? {|k| !["@id", '@type', :usages, RDF.first.to_s, RDF.rest.to_s].include?(k)} &&
+              Array(node[:usages]).length == 1 &&
+              (f = node[RDF.first.to_s]).is_a?(Array) && f.length == 1 &&
+              (r = node[RDF.rest.to_s]).is_a?(Array) && r.length == 1 &&
+              ((t = node['@type']).nil? || t == [RDF.List.to_s])
+            list << Array(node[RDF.first.to_s]).first
+            list_nodes << node['@id']
+            node_usage = Array(node[:usages]).first
+            node, property, head = node_usage[:node], node_usage[:property], node_usage[:value]
+          end
+
+          # If property equals rdf:first, i.e., the detected list is nested inside another list
+          if property == RDF.first.to_s
+            # and the value of the @id of node equals rdf:nil, i.e., the detected list is empty, continue with the next usage item. The rdf:nil node cannot be converted to a list object as it would result in a list of lists, which isn't supported.
+            next if node['@id'] == RDF.nil.to_s
+
+            # Otherwise, the list consists of at least one item. We preserve the head node and transform the rest of the linked list to a list object
+            head_id = head['@id']
+            head = graph_object[head_id]
+            head = Array(head[RDF.rest.to_s]).first
+            list.pop; list_nodes.pop
           end
 
-          next if list.nil?
-          value.delete('@id')
-          value['@list'] = list
-          list_nodes.each {|s| graph_object.delete(s)}
+          head.delete('@id')
+          head['@list'] = list.reverse
+          list_nodes.each {|node_id| graph_object.delete(node_id)}
         end
       end
 
       result = []
-      debug("graph_map") {graph_map.to_json(JSON_STATE)}
       default_graph.keys.sort.each do |subject|
         node = default_graph[subject]
         if graph_map.has_key?(subject)
@@ -104,11 +107,11 @@ module JSON::LD
           graph_map[subject].keys.sort.each do |s|
             n = graph_map[subject][s]
             n.delete(:usages)
-            node['@graph'] << n
+            node['@graph'] << n unless node_reference?(n)
           end
         end
         node.delete(:usages)
-        result << node
+        result << node unless node_reference?(node)
       end
       debug("fromRDF") {result.to_json(JSON_STATE)}
       result