First pass transliteration of @dlonley's named graph framing code.

Author: gkellogg

lib/json/ld/api.rb

@@ -307,12 +307,12 @@ def self.flatten(input, context, options = {})
         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.
-        graphs = {'@default' => {}}
-        create_node_map(value, graphs)
+        graph_maps = {'@default' => {}}
+        create_node_map(value, graph_maps)
 
-        default_graph = graphs['@default']
-        graphs.keys.kw_sort.reject {|k| k == '@default'}.each do |graph_name|
-          graph = graphs[graph_name]
+        default_graph = graph_maps['@default']
+        graph_maps.keys.kw_sort.reject {|k| k == '@default'}.each do |graph_name|
+          graph = graph_maps[graph_name]
           entry = default_graph[graph_name] ||= {'@id' => graph_name}
           nodes = entry['@graph'] ||= []
           graph.keys.kw_sort.each do |id|
@@ -402,7 +402,8 @@ def self.frame(input, frame, options = {})
       }.merge!(options)
 
       framing_state = {
-        graphs:       {'@default' => {}, '@merged' => {}},
+        graphMap:     {'@default' => {}},
+        graphStack:   [],
         subjectStack: [],
         link:         {},
       }
@@ -430,8 +431,18 @@ def self.frame(input, frame, options = {})
         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
-        create_node_map(value, framing_state[:graphs], graph: '@merged')
-        framing_state[:subjects] = framing_state[:graphs]['@merged']
+        create_node_map(value, framing_state[:graphMap], graph: '@default')
+
+        # If Frame is {'@graph': {}] use only the default graph for matches
+        if frame.has_key?('@graph') && frame['@graph'].empty?
+          framing_state[:graph] = '@default'
+        else
+          framing_state[:graph] = '@merged'
+          framing_state[:link]['@merged'] = {}
+          framing_state[:graphMap]['@merged'] = merge_node_map_graphs(framing_state[:graphMap])
+        end
+
+        framing_state[:subjects] = framing_state[:graphMap][framing_state[:graph]]
 
         result = []
         frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), options.merge(parent: result))

lib/json/ld/expand.rb

@@ -129,7 +129,8 @@ def expand(input, active_property, context, ordered: true)
               end
             when '@graph'
               # If expanded property is @graph, set expanded value to the result of using this algorithm recursively passing active context, @graph for active property, and value for element.
-              expand(value, '@graph', context, ordered: ordered)
+              value = expand(value, '@graph', context, ordered: ordered)
+              value.is_a?(Array) ? value : [value]
             when '@value'
               # If expanded property is @value and value is not a scalar or null, an invalid value object value error has been detected and processing is aborted. Otherwise, set expanded value to value. If expanded value is null, set the @value member of result to null and continue with the next key from element. Null values need to be preserved in this case as the meaning of an @type member depends on the existence of an @value member.
               # If framing, always use array form, unless null

lib/json/ld/flatten.rb

@@ -68,8 +68,7 @@ def create_node_map(input, graphs, graph: '@default', name: nil, list: nil)
               end
             when '@graph'
               graphs[name] ||= {}
-              g = graph == '@merged' ? graph : name
-              create_node_map(objects, graphs, graph: g)
+              create_node_map(objects, graphs, graph: name)
             when /^@(?!type)/
               # copy non-@type keywords
               if property == '@index' && subject['@index']
@@ -115,5 +114,35 @@ def create_node_map(input, graphs, graph: '@default', name: nil, list: nil)
         list << input if list
       end
     end
+
+  private
+    ##
+    # Merge nodes from all graphs in the graph_map into a new node map
+    #
+    # @param [Hash{String => Hash}] graph_map
+    # @return [Hash]
+    def merge_node_map_graphs(graph_map)
+      merged = {}
+      graph_map.each do |name, node_map|
+        node_map.each do |id, node|
+          merged_node = (merged[id] ||= {'@id' => id})
+
+          # Iterate over node properties
+          node.each do |property, values|
+            if property.start_with?('@')
+              # Copy keywords
+              merged_node[property] = node[property].dup
+            else
+              # Merge objects
+              values.each do |value|
+                add_value(merged_node, property, value.dup, property_is_array: true)
+              end
+            end
+          end
+        end
+      end
+
+      merged
+    end
   end
 end

lib/json/ld/frame.rb

@@ -19,6 +19,11 @@ module Frame
     #   The parent property.
     # @raise [JSON::LD::InvalidFrame]
     def frame(state, subjects, frame, **options)
+      log_depth do
+      log_debug("frame") {"subjects: #{subjects.inspect}"}
+      log_debug("frame") {"frame: #{frame.to_json(JSON_STATE)}"}
+      log_debug("frame") {"property: #{options[:property].inspect}"}
+
       parent, property = options[:parent], options[:property]
       # Validate the frame
       validate_frame(frame)
@@ -31,6 +36,9 @@ def frame(state, subjects, frame, **options)
         requireAll: get_frame_flag(frame, options, :requireAll),
       }
 
+      # Get link for current graph
+      link = state[:link][state[:graph]] ||= {}
+
       # Create a set of matched subjects by filtering subjects by checking the map of flattened subjects against frame
       # This gives us a hash of objects indexed by @id
       matches = filter_subjects(state, subjects, frame, flags)
@@ -40,35 +48,64 @@ def frame(state, subjects, frame, **options)
         subject = matches[id]
 
         # Note: In order to treat each top-level match as a compartmentalized result, clear the unique embedded subjects map when the property is None, which only occurs at the top-level.
-        state = state.merge(uniqueEmbeds: {}) if property.nil?
+        if property.nil?
+          state[:uniqueEmbeds] = {state[:graph] => {}}
+        else
+          state[:uniqueEmbeds][state[:graph]] ||= {}
+        end
 
-        if flags[:embed] == '@link' && state[:link].has_key?(id)
+        if flags[:embed] == '@link' && link.has_key?(id)
           # add existing linked subject
-          add_frame_output(parent, property, state[:link][id])
+          add_frame_output(parent, property, link[id])
           next
         end
 
         output = {'@id' => id}
-        state[:link][id] = output
+        link[id] = output
 
         # if embed is @never or if a circular reference would be created by an embed, the subject cannot be embedded, just add the reference; note that a circular reference won't occur when the embed flag is `@link` as the above check will short-circuit before reaching this point
-        if flags[:embed] == '@never' || creates_circular_reference(subject, state[:subjectStack])
+        if flags[:embed] == '@never' || creates_circular_reference(subject, state[:graph], state[:subjectStack])
           add_frame_output(parent, property, output)
           next
         end
 
         # if only the last match should be embedded
         if flags[:embed] == '@last'
           # remove any existing embed
-          remove_embed(state, id) if state[:uniqueEmbeds].include?(id)
-          state[:uniqueEmbeds][id] = {
+          remove_embed(state, id) if state[:uniqueEmbeds][state[:graph]].include?(id)
+          state[:uniqueEmbeds][state[:graph]][id] = {
             parent: parent,
             property: property
           }
         end
 
         # push matching subject onto stack to enable circular embed checks
-        state[:subjectStack] << subject
+        state[:subjectStack] << {subject: subject, graph: state[:graph]}
+
+        # Subject is also the name of a graph
+        if state[:graphMap].has_key?(id)
+          # check frame's "@graph" to see what to do next
+          # 1. if it doesn't exist and state.graph === "@merged", don't recurse
+          # 2. if it doesn't exist and state.graph !== "@merged", recurse
+          # 3. if "@merged" then don't recurse
+          # 4. if "@default" then don't recurse
+          # 5. recurse
+          recurse, subframe = false, nil
+          if !frame.has_key?('@graph')
+            recurse, subframe = (state[:graph] != '@merged'), {}
+          else
+            subframe = frame['@graph'].first
+            recurse = !%w(@merged @default).include?(subframe)
+            subframe = {} unless subframe.is_a?(Hash)
+          end
+
+          if recurse
+            state[:graphStack].push(state[:graph])
+            state[:graph] = id
+            frame(state, state[:graphMap][id].keys, [subframe], options.merge(parent: output, property: '@graph'))
+            state[:graph] = state[:graphStack].pop
+          end
+        end
 
         # iterate over subject properties in order
         subject.keys.kw_sort.each do |prop|
@@ -141,6 +178,7 @@ def frame(state, subjects, frame, **options)
         # pop matching subject from circular ref-checking stack
         state[:subjectStack].pop()
       end
+      end
     end
 
     ##
@@ -193,7 +231,7 @@ def cleanup_preserve(input)
     # @return all of the matched subjects.
     def filter_subjects(state, subjects, frame, flags)
       subjects.inject({}) do |memo, id|
-        subject = state[:subjects][id]
+        subject = state[:graphMap][state[:graph]][id]
         memo[id] = subject if filter_subject(subject, frame, state, flags)
         memo
       end
@@ -306,12 +344,13 @@ def validate_frame(frame)
     # Checks the current subject stack to see if embedding the given subject would cause a circular reference.
     # 
     # @param subject_to_embed the subject to embed.
+    # @param graph the graph the subject to embed is in.
     # @param subject_stack the current stack of subjects.
     # 
     # @return true if a circular reference would be created, false if not.
-    def creates_circular_reference(subject_to_embed, subject_stack)
+    def creates_circular_reference(subject_to_embed, graph, subject_stack)
       subject_stack[0..-2].any? do |subject|
-        subject['@id'] == subject_to_embed['@id']
+        subject[:graph] == graph && subject[:subject]['@id'] == subject_to_embed['@id']
       end
     end
 
@@ -344,7 +383,7 @@ def get_frame_flag(frame, options, name)
     # @param id the @id of the embed to remove.
     def remove_embed(state, id)
       # get existing embed
-      embeds = state[:uniqueEmbeds];
+      embeds = state[:uniqueEmbeds][state[:graph]];
       embed = embeds[id];
       property = embed[:property];
 

spec/expand_spec.rb

@@ -43,6 +43,25 @@
           {"http://example.com/bar" => [{"@value" => "bar"}]}
         ]
       },
+      "@graph value (expands to array form)" => {
+        input: {
+          "@context" => {"ex" => "http://example.com/"},
+          "ex:p" => {
+            "@id" => "ex:Sub1",
+            "@graph" => {
+              "ex:q" => "foo"
+            }
+          }
+        },
+        output: [{
+          "http://example.com/p" => [{
+            "@id" => "http://example.com/Sub1",
+            "@graph" => [{
+              "http://example.com/q" => [{"@value" => "foo"}],
+            }]
+          }]
+        }]
+      },
       "@type with CURIE" => {
         input: {
           "@context" => {"ex" => "http://example.com/"},