Update flatten algorithm to handle embedded nodes and annotation objects.

Note: there remains a problem with consistent Bnode renaming inside embedded objects.

Author: gkellogg

lib/json/ld/api.rb

@@ -480,16 +480,16 @@ def self.toRdf(input, expanded: false, **options, &block)
         extractAllScripts:  true,
       }.merge(options)
 
-      # Expand input to simplify processing
-      expanded_input = expanded ? input : API.expand(input, ordered: false, **options)
+      # Flatten input to simplify processing
+      flattened_input = API.flatten(input, nil, expanded: expanded, ordered: false, **options)
 
-      API.new(expanded_input, nil, **options) do
+      API.new(flattened_input, nil, **options) do
         # 1) Perform the Expansion Algorithm on the JSON-LD input.
         #    This removes any existing context to allow the given context to be cleanly applied.
-        log_debug(".toRdf") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".toRdf") {"flattened input: #{flattened_input.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Recurse through input
-        expanded_input.each do |node|
+        flattened_input.each do |node|
           item_to_rdf(node) do |statement|
             next if statement.predicate.node? && !options[:produceGeneralizedRdf]
 

lib/json/ld/flatten.rb

@@ -1,12 +1,18 @@
 # -*- encoding: utf-8 -*-
 # frozen_string_literal: true
+require 'json/canonicalization'
+
 module JSON::LD
   module Flatten
     include Utils
 
     ##
     # 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.
     #
+    # For RDF*/JSON-LD*:
+    #   * Values of `@id` can be an object (embedded node); when these are used as keys in a Node Map, they are serialized as canonical JSON, and de-serialized when flattening.
+    #   * The presence of `@annotation` implies an embedded node and the annotation object is removed from the node/value object in which it appears.
+    #
     # @param [Array, Hash] element
     #   Expanded JSON-LD input
     # @param [Hash] graph_map A map of graph name to subjects
@@ -16,12 +22,15 @@ module Flatten
     #   Node identifier
     # @param [String] active_property (nil)
     #   Property within current node
+    # @param [Boolean] reverse (false)
+    #   Processing a reverse relationship
     # @param [Array] list (nil)
     #   Used when property value is a list
     def create_node_map(element, graph_map,
                         active_graph: '@default',
                         active_subject: nil,
                         active_property: nil,
+                        reverse: false,
                         list: nil)
       if element.is_a?(Array)
         # If element is an array, process each entry in element recursively by passing item for element, node map, active graph, active subject, active property, and list.
@@ -30,13 +39,14 @@ def create_node_map(element, graph_map,
                           active_graph: active_graph,
                           active_subject: active_subject,
                           active_property: active_property,
+                          reverse: false,
                           list: list)
         end
       elsif !element.is_a?(Hash)
         raise "Expected hash or array to create_node_map, got #{element.inspect}"
       else
         graph = (graph_map[active_graph] ||= {})
-        subject_node = !active_subject.is_a?(Hash) && graph[active_subject]
+        subject_node = !reverse && graph[active_subject.is_a?(Hash) ? active_subject.to_json_c14n : active_subject]
 
         # Transform BNode types
         if element.has_key?('@type')
@@ -45,6 +55,29 @@ def create_node_map(element, graph_map,
 
         if value?(element)
           element['@type'] = element['@type'].first if element ['@type']
+
+          # For rdfstar, if value contains an `@annotation` member ...
+          # note: active_subject will not be nil, and may be an object itself.
+          if element.key?('@annotation')
+            # rdfstar being true is implicit, as it is checked in expansion
+            as = node_reference?(active_subject) ?
+              active_subject['@id'] :
+              active_subject
+            star_subject = {
+              "@id" => as,
+              active_property => [element]
+            }
+
+            # Note that annotation is an array, make the reified subject the id of each member of that array.
+            annotation = element.delete('@annotation').map do |a|
+              a.merge('@id' => star_subject)
+            end
+
+            # Invoke recursively using annotation.
+            create_node_map(annotation, graph_map,
+                            active_graph: active_graph)
+          end
+
           if list.nil?
             add_value(subject_node, active_property, element, property_is_array: true, allow_duplicate: false)
           else
@@ -64,13 +97,21 @@ def create_node_map(element, graph_map,
           end
         else
           # Element is a node object
-          id = element.delete('@id')
-          id = namer.get_name(id) if blank_node?(id)
+          ser_id = id = element.delete('@id')
+          if id.is_a?(Hash)
+            # recursively rename blank nodes within `id`.
+            id = rename_embedded(id)
+            # Index graph using serialized id
+            ser_id = id.to_json_c14n
+          elsif blank_node?(id)
+            ser_id = id = namer.get_name(id)
+          end
 
-          node = graph[id] ||= {'@id' => id}
+          node = graph[ser_id] ||= {'@id' => id}
 
-          if active_subject.is_a?(Hash)
-            # If subject is a hash, then we're processing a reverse-property relationship.
+          if reverse
+            # Note: active_subject is a Hash
+            # We're processing a reverse-property relationship.
             add_value(node, active_property, active_subject, property_is_array: true, allow_duplicate: false)
           elsif active_property
             reference = {'@id' => id}
@@ -81,6 +122,29 @@ def create_node_map(element, graph_map,
             end
           end
 
+          # For rdfstar, if node contains an `@annotation` member ...
+          # note: active_subject will not be nil, and may be an object itself.
+          # XXX: what if we're reversing an annotation?
+          if element.key?('@annotation')
+            # rdfstar being true is implicit, as it is checked in expansion
+            as = node_reference?(active_subject) ?
+              active_subject['@id'] :
+              active_subject
+            star_subject = reverse ? 
+              {"@id" => node['@id'], active_property => [{'@id' => as}]} :
+              {"@id" => as, active_property => [{'@id' => node['@id']}]}
+
+            # Note that annotation is an array, make the reified subject the id of each member of that array.
+            annotation = element.delete('@annotation').map do |a|
+              a.merge('@id' => star_subject)
+            end
+
+            # Invoke recursively using annotation.
+            create_node_map(annotation, graph_map,
+                            active_graph: active_graph,
+                            active_subject: star_subject)
+          end
+
           if element.has_key?('@type')
             add_value(node, '@type', element.delete('@type'), property_is_array: true, allow_duplicate: false)
           end
@@ -99,7 +163,8 @@ def create_node_map(element, graph_map,
                 create_node_map(value, graph_map,
                                 active_graph: active_graph,
                                 active_subject: referenced_node,
-                                active_property: property)
+                                active_property: property,
+                                reverse: true)
               end
             end
           end
@@ -128,7 +193,26 @@ def create_node_map(element, graph_map,
       end
     end
 
+    ##
+    # Rename blank nodes recursively within an embedded object
+    #
+    # @param [Object] node
+    # @return [Hash]
+    def rename_embedded(node)
+      case node
+      when String
+        blank_node?(node) ? namer.get_name(node) : node
+      when Array
+        node.map {|n| rename_embedded(n)}
+      when Hash
+        node.inject({}) {|memo, (k, v)| memo.merge(k => rename_embedded(v))}
+      else
+        node
+      end
+    end
+
   private
+
     ##
     # Merge nodes from all graphs in the graph_map into a new node map
     #