json-ld 0.9.1 → 1.0.0

data/lib/json/ld/extensions.rb

@@ -32,6 +32,13 @@ module RDF
     end
   end
   
+  class Node
+    # Odd case of appending to a BNode identifier
+    def +(value)
+      Node.new(id + value.to_s)
+    end
+  end
+
   class Literal
     class Double
       ##
@@ -63,8 +70,9 @@ class Array
   # @yieldparam [Object] b
   # @yieldreturn [Integer]
   # @return [Array]
-  KW_ORDER = %(@id @value @type @language @vocab @container @graph @list @set)
+  KW_ORDER = %w(@base @id @value @type @language @vocab @container @graph @list @set @index).freeze
 
+  # Order, considering keywords to come before other strings
   def kw_sort
     self.sort do |a, b|
       a = "@#{KW_ORDER.index(a)}" if KW_ORDER.include?(a)
@@ -72,6 +80,14 @@ class Array
       a <=> b
     end
   end
+
+  # Order terms, length first, then lexographically
+  def term_sort
+    self.sort do |a, b|
+      len_diff = a.length <=> b.length
+      len_diff == 0 ? a <=> b : len_diff
+    end
+  end
 end
 
 if RUBY_VERSION < "1.9"

data/lib/json/ld/flatten.rb

@@ -3,104 +3,171 @@ module JSON::LD
     include Utils
 
     ##
-    # Build hash of nodes used for framing. Also returns flattened representation of input.
+    # This algorithm creates a JSON object node map holding an indexed representation of the graphs and nodes represented in the passed expanded document. All nodes that are not uniquely identified by an IRI get assigned a (new) blank node identifier. The resulting node map will have a member for every graph in the document whose value is another object with a member for every node represented in the document. The default graph is stored under the @default member, all other graphs are stored under their graph name.
     #
     # @param [Array, Hash] element
     #   Expanded element
     # @param [Hash{String => Hash}] node_map
     #   map of nodes
-    # @param [String] graph
+    # @param [String] active_graph
     #   Graph name for results
     # @param [Array] list
     #   List for saving list elements
     # @param [String] id (nil)
     #   Identifier already associated with element
-    def generate_node_map(element, node_map, graph, list = nil, id = nil)
+    def generate_node_map(element,
+                          node_map,
+                          active_graph    = '@default',
+                          active_subject  = nil,
+                          active_property = nil,
+                          list            = nil)
       depth do
-        debug("nodeMap") {"element: #{element.inspect}, graph: #{graph}"}
+        debug("node_map") {"active_graph: #{active_graph}, element: #{element.inspect}"}
         if element.is_a?(Array)
-          element.map {|o| generate_node_map(o, node_map, graph, list)}
-        elsif !element.is_a?(Hash) || value?(element)
-          list << element if list
+          # If element is an array, process each entry in element recursively, using this algorithm and return
+          element.map {|o|
+            generate_node_map(o,
+                              node_map,
+                              active_graph,
+                              active_subject,
+                              active_property,
+                              list)
+          }
         else
-          # If the @id property exists and is an IRI, set id to its value, otherwise set it to a blank node identifier created by the Generate Blank Node Identifier algorithm.
-          # FIXME: (spec) id passed when it is allocated, so it is not re-allocated here.
-          id ||= blank_node?(element) ? namer.get_name(element.fetch('@id', nil)) : element['@id']
-          
-          # If list is not nil, append a new node reference to list using id at the value for @id.
-          list << {'@id' => id} if list
-
-          # Let nodes be the value in nodeMap where the key is graph; if no such value exists, insert a new JSON object for the key graph.
-          debug("nodeMap") {"new graph: #{graph}"} unless node_map.has_key?(graph)
-          nodes = (node_map[graph] ||= Hash.ordered)
-
-          # If id is not in nodes, create a new JSON object node with id as the value for @id. Let node be the value of id in nodes.
-          debug("nodeMap") {"new node: #{id}"} unless nodes.has_key?(id)
-          node = (nodes[id] ||= Hash.ordered)
-          node['@id'] ||= id
-
-          # For each property that is not @id and each value in element ordered by property:
-          element.each do |prop, value|
-            case prop
-            when '@id'
-              # Skip @id, already assigned
-            when '@graph'
-              # If property is @graph, recursively call this algorithm passing value for element, nodeMap, nil for list and if graph is @merged use graph, otherwise use id for graph and then continue.
-              graph = graph == '@merged' ? '@merged' : id
-              generate_node_map(value, node_map, graph)
-            when /^@(?!type)/
-              # If property is not @type and is a keyword, merge property and value into node and then continue.
-              debug("nodeMap") {"merge keyword#{prop}: #{value.inspect}"}
-              node[prop] = value
+          # Otherwise element is a JSON object. Reference the JSON object which is the value of the active graph member of node map using the variable graph. If the active subject is null, set node to null otherwise reference the active subject member of graph using the variable node.
+          # Spec FIXME: initializing it to an empty JSON object, if necessary
+          raise "Expected element to be a hash, was #{element.class}" unless element.is_a?(Hash)
+          graph = node_map[active_graph] ||= Hash.ordered
+          node = graph[active_subject] if active_subject
+
+          # 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|
+              # 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
+            end
+
+            element['@type'] = element['@type'].is_a?(Array) ? types : types.first
+          end
+
+          # If element has an @value member, perform the following steps:
+          if value?(element)
+            unless list
+              # If no list has been passed, merge element into the active property member of the active subject in graph.
+              merge_value(node, active_property, element)
             else
-              raise InvalidFrame::Syntax,
-                "unexpected value: #{value.inspect}, expected array" unless
-                value.is_a?(Array)
-              
-              # For each value v in the array value:
-              value.each do |v|
-                if node?(v) || node_reference?(v)
-                  debug("nodeMap") {"node value #{prop}: #{v.inspect}"}
-                  # If v is a node definition or node reference:
-                  # If the property @id is not an IRI or it does not exist, map v to a new blank node identifier to avoid collisions.
-                  name = blank_node?(v) ?
-                    namer.get_name(v.fetch('@id', nil)) :
-                    v['@id']
-
-                  # If one does not already exist, add a node reference for v into node for property.
-                  node[prop] ||= []
-                  node[prop] << {'@id' => name} unless node[prop].any? {|n|
-                    node_reference?(n) && n['@id'] == name
-                  }
-
-                  # Recursively call this algorithm passing v for value, nodeMap, graph, and nil for list.
-                  generate_node_map(v, node_map, graph, nil, name)
-                elsif list?(v)
-                  # Otherwise if v has the property @list then recursively call this algorithm with the value of @list as element, nodeMap, graph, and a new array flattenedList as list.
-                  debug("nodeMap") {"list value #{prop}: #{v.inspect}"}
-                  flattened_list = []
-                  generate_node_map(v['@list'],
-                    node_map,
-                    graph,
-                    flattened_list)
-                  # Create a new JSON object with the property @list set to flattenedList and add it to node for property.
-                  (node[prop] ||= []) << {'@list' => flattened_list}
-                elsif prop == '@type'
-                  # Otherwise, if property is @type and v is not an IRI, generate a new blank node identifier and add it to node for property.
-                  # FIXME: @type shouldn't really be a BNode, and not clear how we even get here from expansion
-                  name = blank_node?({'@id' => v}) ? namer.get_name(v) : v
-                  (node[prop] ||= []) << name
-                else
-                  debug("nodeMap") {"value #{prop}: #{v.inspect}"}
-                  # Otherwise, add v to node for property.
-                  (node[prop] ||= []) << v
+              # Otherwise, append element to the @list member of list.
+              merge_value(list, '@list', element)
+            end
+          elsif list?(element)
+            # Otherwise, if element has an @list member, perform the following steps:
+            # Initialize a new JSON object result having a single member @list whose value is initialized to an empty array.
+            result = {'@list' => []}
+
+            # Recursively call this algorithm passing the value of element's @list member as new element and result as list.
+            generate_node_map(element['@list'],
+                              node_map,
+                              active_graph,
+                              active_subject,
+                              active_property,
+                              result)
+
+            # Append result to the the value of the active property member of node.
+            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')
+            id = namer.get_name(id) if blank_node?(id)
+            debug("node_map") {"id: #{id.inspect}"}
+
+            # If graph does not contain a member id, create one and initialize it to a JSON object consisting of a single member @id whose value is set to id.
+            graph[id] ||= Hash.ordered
+            graph[id]['@id'] ||= id
+
+            # If active property is not null, perform the following steps:
+            if active_property
+              # Create a new JSON object reference consisting of a single member @id whose value is id.
+              reference = Hash.ordered
+              reference['@id'] = id
+
+              # If list is null:
+              unless list
+                merge_value(node, active_property, reference)
+              else
+                merge_value(list, '@list', reference)
+              end
+            end
+
+            # Reference the value of the id member of graph using the variable node.
+            node = graph[id]
+
+            # 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|
+                merge_value(node, '@type', t)
+              end
+            end
+
+            # If element has an @index member, set the @index member of node to its value. If node has already an @index member with a different value, a conflicting indexes error has been detected and processing is aborted. Otherwise, continue by removing the @index member from element.
+            if element.has_key?('@index')
+              raise ProcessingError::ConflictingIndexesError,
+                    "Element already has index #{node['@index']} dfferent from #{element['@index']}" if
+                    node['@index'] && node['@index'] != element['@index']
+              node['@index'] = element.delete('@index')
+            end
+
+            # If element has an @reverse member:
+            if element.has_key?('@reverse')
+              element.delete('@reverse').each do |property, values|
+                values.each do |value|
+                  debug("node_map") {"@reverse(#{id}): #{value.inspect}"}
+                  # If value has a property member, append referenced node to its value; otherwise create a property member whose value is an array containing referenced node.
+                  merge_value(value, property, {'@id' => id})
+
+                  # Recursively invoke this algorithm passing value for element, node map, and active graph.
+                  generate_node_map(value,
+                                    node_map,
+                                    active_graph)
                 end
               end
             end
+
+            # If element has an @graph member, recursively invoke this algorithm passing the value of the @graph member for element, node map, and id for active graph before removing the @graph member from element.
+            if element.has_key?('@graph')
+              generate_node_map(element.delete('@graph'),
+                                node_map,
+                                id)
+            end
+
+            # Finally, for each key-value pair property-value in element ordered by property perform the following steps:
+            element.keys.sort.each do |property|
+              value = element[property]
+
+              # If property is a blank node identifier, replace it with a newly generated blank node identifier passing property for identifier.
+              property = namer.get_name(property) if blank_node?(property)
+
+              # If node does not have a property member, create one and initialize its value to an empty array.
+              node[property] ||= []
+
+              # Recursively invoke this algorithm passing value as new element, id as new active subject, and property as new active property.
+              generate_node_map(value,
+                                node_map,
+                                active_graph,
+                                id,
+                                property,
+                                list)
+            end
           end
         end
 
-        debug("nodeMap") {node_map.to_json(JSON_STATE)}
+        debug("node_map") {node_map.to_json(JSON_STATE)}
       end
     end
   end

data/lib/json/ld/frame.rb

@@ -255,7 +255,7 @@ module JSON::LD
 
     def validate_frame(state, frame)
       raise InvalidFrame::Syntax,
-            "Invalid JSON-LD syntax; a JSON-LD frame must be an object" unless frame.is_a?(Hash)
+            "Invalid JSON-LD syntax; a JSON-LD frame must be an object: #{frame.inspect}" unless frame.is_a?(Hash)
     end
     
     # Return value of @name in frame, or default from state if it doesn't exist

data/lib/json/ld/from_rdf.rb

@@ -11,11 +11,11 @@ module JSON::LD
     # @param [Array<RDF::Statement>, RDF::Enumerable] input
     # @return [Array<Hash>] the JSON-LD document in normalized form
     def from_statements(input)
-      defaultGraph = {:nodes => {}, :listMap => {}, :name => ''}
-      graphs = {'' => defaultGraph}
+      default_graph = {}
+      graph_map = {'@default' => default_graph}
 
       value = nil
-      ec = EvaluationContext.new
+      ec = Context.new
 
       # Create a map for node to object representation
 
@@ -23,125 +23,95 @@ module JSON::LD
       input.each do |statement|
         debug("statement") { statement.to_nquads.chomp}
 
-        subject = ec.expand_iri(statement.subject).to_s
-        name = statement.context ? ec.expand_iri(statement.context).to_s : ''
+        name = statement.context ? ec.expand_iri(statement.context).to_s : '@default'
         
         # Create a graph entry as needed
-        graph = graphs[name] ||= {:nodes => {}, :listMap => {}, :name => name}
+        node_map = graph_map[name] ||= {}
+        default_graph[name] ||= {'@id' => name} unless name == '@default'
         
-        case statement.predicate
-        when RDF.first
-          # If property is rdf:first,
-          # create a new entry in _listMap_ for _name_ and _subject_ and an array value
-          # containing the object representation and continue to the next statement.
-          listMap = graph[:listMap]
-          entry = listMap[subject] ||= {}
-          object_rep = ec.expand_value(nil, statement.object)
-          entry[:first] = object_rep
-          debug("rdf:first") { "save entry for #{subject.inspect} #{entry.inspect}"}
-          next
-        when RDF.rest
-          # If property is rdf:rest,
-          # and object is a blank node,
-          # create a new entry in _restMap_ for _name_ and _subject_ and a value being the
-          # result of IRI expansion on the object and continue to the next statement.
-          next unless statement.object.is_a?(RDF::Node)
-
-          listMap = graph[:listMap]
-          entry = listMap[subject] ||= {}
-
-          object_rep = ec.expand_iri(statement.object).to_s
-          entry[:rest] = object_rep
-          debug("rdf:rest") { "save entry for #{subject.inspect} #{entry.inspect}"}
+        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.
+        node_map[statement.object.to_s] ||= {'@id' => statement.object.to_s} unless
+        statement.object.literal? || statement.object == RDF.nil
+
+        # 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?
+          merge_value(node, '@type', statement.object.to_s)
           next
         end
 
-        # Add entry to default graph for name unless it is empty
-        defaultGraph[:nodes][name] ||= {'@id' => name} unless name.empty?
-        
-        # Get value from graph nodes for subject, initializing it to a new node declaration for subject if it does not exist
-        debug("@id") { "new subject: #{subject}"} unless graph[:nodes].has_key?(subject)
-        value = graph[:nodes][subject] ||= {'@id' => subject}
-
-        # If property is http://www.w3.org/1999/02/22-rdf-syntax-ns#type
-        # and the useRdfType option is not true
-        if statement.predicate == RDF.type && !@options[:useRdfType]
-          object = ec.expand_iri(statement.object).to_s
-          debug("@type") { object.inspect}
-          # append the string representation of object to the array value for the key @type, creating
-          # an entry if necessary
-          (value['@type'] ||= []) << object
-        # FIXME: 3.7) If object is a typed literal and the useNativeTypes option is set to true:
-        elsif statement.object == RDF.nil
-          # Otherwise, if object is http://www.w3.org/1999/02/22-rdf-syntax-ns#nil, let
-          # key be the string representation of predicate. Set the value
-          # for key to an empty @list representation {"@list": []}
-          key = ec.expand_iri(statement.predicate).to_s
-          (value[key] ||= []) << {"@list" => []}
+        # 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
-          # Otherwise, let key be the string representation of predicate and 
-          # let object representation be object represented in expanded form as 
-          # described in Value Expansion.
-          key = ec.expand_iri(statement.predicate).to_s
-          object = ec.expand_value(key, statement.object, @options)
-          if blank_node?(object)
-            # if object is an Unnamed Node, set as the head element in the listMap
-            # entry for object
-            listMap = graph[:listMap]
-            entry = listMap[object['@id']] ||= {}
-            entry[:head] = object
-            debug("bnode") { "save entry #{entry.inspect}"}
-          end
+          ec.expand_value(nil, statement.object, @options)
+        end
 
-          debug("key/value") { "key: #{key}, :value #{object.inspect}"}
-          
-          # append the object object representation to the array value for key, creating
-          # an entry if necessary
-          (value[key] ||= []) << object
+        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)
         end
       end
 
-      # Build lists for each graph
-      graphs.each do |name, graph|
-        graph[:listMap].each do |subject, entry|
-          debug("listMap(#{name}, #{subject})") { entry.inspect}
-          if entry.has_key?(:head) && entry.has_key?(:first)
-            debug("@list") { "List head for #{subject.inspect} in #{name.inspect}: #{entry.inspect}"}
-            value = entry[:head]
-            value.delete('@id')
-            list = value['@list'] = [entry[:first]].compact
-            
-            while rest = entry.fetch(:rest, nil)
-              entry = graph[:listMap][rest]
-              debug(" => ") { "add #{entry.inspect}"}
-              raise JSON::LD::ProcessingError, "list entry missing rdf:first" unless entry.has_key?(:first)
-              list << entry[:first]
+      # 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
           end
+
+          next if list.nil?
+          value.delete('@id')
+          value['@list'] = list
+          list_nodes.each {|s| graph_object.delete(s)}
         end
       end
 
-      # Build graphs in @id order
-      debug("graphs") {graphs.to_json(JSON_STATE)}
-      array = defaultGraph[:nodes].keys.sort.map do |subject|
-        entry = defaultGraph[:nodes][subject]
-        debug("=> default") {entry.to_json(JSON_STATE)}
-        
-        # If subject is a named graph, add serialized subject defintions
-        if graphs.has_key?(subject) && !subject.empty?
-          entry['@graph'] = graphs[subject][:nodes].keys.sort.map do |s|
-            debug("=> #{s.inspect}")
-            graphs[subject][:nodes][s]
+      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)
+          node['@graph'] = []
+          graph_map[subject].keys.sort.each do |s|
+            n = graph_map[subject][s]
+            n.delete(:usages)
+            node['@graph'] << n
           end
         end
-        
-        debug("default graph") {entry.inspect}
-        entry
+        node.delete(:usages)
+        result << node
       end
-
-      # Return array as the graph representation.
-      debug("fromRDF") {array.to_json(JSON_STATE)}
-      array
+      debug("fromRDF") {result.to_json(JSON_STATE)}
+      result
     end
   end
 end