Make sure that serialized context uses strings, and not RDF::URI.

Author: gkellogg

lib/json/ld/api.rb

@@ -330,7 +330,7 @@ def self.frame(input, frame, options = {})
         debug(".frame") {"node_map: #{@node_map.to_json(JSON_STATE)}"}
 
         result = []
-        frame(framing_state, @node_map, (expanded_frame.first || {}), result, nil)
+        frame(framing_state, @node_map, (expanded_frame.first || {}), parent: result)
         debug(".frame") {"after frame: #{result.to_json(JSON_STATE)}"}
 
         # Initalize context from frame

lib/json/ld/context.rb

@@ -8,7 +8,7 @@ class Context
 
     # Term Definitions specify how properties and values have to be interpreted as well as the current vocabulary mapping and the default language
     class TermDefinition
-      # @return [String] IRI map
+      # @return [RDF::URI] IRI map
       attr_accessor :id
 
       # @return [String] term name
@@ -63,10 +63,10 @@ def to_context_definition(context)
            type_mapping.nil? &&
            reverse_property.nil?
 
-           cid unless cid == term && context.vocab
+           cid.to_s unless cid == term && context.vocab
         else
           defn = {}
-          defn[reverse_property ? '@reverse' : '@id'] = cid unless cid == term && !reverse_property
+          defn[reverse_property ? '@reverse' : '@id'] = cid.to_s unless cid == term && !reverse_property
           if type_mapping
             defn['@type'] = if KEYWORDS.include?(type_mapping)
               type_mapping
@@ -126,7 +126,7 @@ def inspect
     #
     # Sets the default vocabulary used for expanding terms which
     # aren't otherwise absolute IRIs
-    # @return [String]
+    # @return [RDF::URI]
     attr_reader :vocab
 
     # @return [Hash{Symbol => Object}] Global options used in generating IRIs

lib/json/ld/frame.rb

@@ -10,13 +10,15 @@ module Frame
     # @param [Hash{String => Hash}] nodes
     #   Map of flattened nodes
     # @param [Hash{String => Object}] frame
-    # @param [Hash{String => Object}] parent
+    # @param [Hash{Symbol => Object}] options ({})
+    # @option options [Hash{String => Object}] :parent
     #   Parent node or top-level array
-    # @param [String] property
+    # @option options [String] :property
     #   Property referencing this frame, or null for array.
     # @raise [JSON::LD::InvalidFrame]
-    def frame(state, nodes, frame, parent, property)
+    def frame(state, nodes, frame, options = {})
       depth do
+        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)}"}
@@ -48,9 +50,7 @@ def frame(state, nodes, frame, parent, property)
 
           # If embedOn is true, and id is in map of embeds from state
           if embed && (existing = state[:embeds].fetch(id, nil))
-            # only overwrite an existing embed if it has already been added to its
-            # parent -- otherwise its parent is somewhere up the tree from this
-            # embed and the embed would occur twice once the tree is added
+            # only overwrite an existing embed if it has already been added to its parent -- otherwise its parent is somewhere up the tree from this embed and the embed would occur twice once the tree is added
             embed = false
 
             embed = if existing[:parent].is_a?(Array)
@@ -114,7 +114,7 @@ def frame(state, nodes, frame, parent, property)
                       debug("frame") {"list item of #{prop} recurse for #{itemid.inspect}"}
 
                       # If listitem is a node reference process listitem recursively using this algorithm passing a new map of nodes that contains the @id of listitem as the key and the node reference as the value. Pass the first value from frame for property as frame, list as parent, and @list as active property.
-                      frame(state, {itemid => @node_map[itemid]}, frame[prop].first, list, '@list')
+                      frame(state, {itemid => @node_map[itemid]}, frame[prop].first, parent: list, property: '@list')
                     else
                       # Otherwise, append a copy of listitem to @list in list.
                       debug("frame") {"list item of #{prop} non-node ref #{listitem.inspect}"}
@@ -128,7 +128,7 @@ def frame(state, nodes, frame, parent, property)
                   debug("frame") {"value property #{prop} recurse for #{itemid.inspect}"}
 
                   # passing a new map as nodes that contains the @id of item as the key and the node reference as the value. Pass the first value from frame for property as frame, output as parent, and property as active property
-                  frame(state, {itemid => @node_map[itemid]}, frame[prop].first, output, prop)
+                  frame(state, {itemid => @node_map[itemid]}, frame[prop].first, parent: output, property: prop)
                 else
                   # Otherwise, append a copy of item to active property in output.
                   debug("frame") {"value property #{prop} non-node ref #{item.inspect}"}

spec/frame_spec.rb

@@ -512,5 +512,58 @@
         end
       end
     end
+
+    describe "@reverse", skip:true do
+      {
+        "embed matched frames with @reverse" => {
+          :frame => {
+            "@context" => {"ex" => "http://example.org/"},
+            "@type" => "ex:Type1",
+            "@reverse" => {
+              "ex:includes" => {}
+            }
+          },
+          :input => [
+            {
+              "@context" => {"ex" => "http://example.org/"},
+              "@id" => "ex:Sub1",
+              "@type" => "ex:Type1"
+            },
+            {
+              "@context" => {"ex" => "http://example.org/"},
+              "@id" => "ex:Sub2",
+              "@type" => "ex:Type2",
+              "ex:includes" => {"@id" => "ex:Sub1"}
+            },
+          ],
+          :output =>{
+            "@context" => {"ex" => "http://example.org/"},
+            "@graph" => [{
+              "@id" => "ex:Sub1",
+              "@type" => "ex:Type1",
+              "@reverse" => {
+                "ex:includes" => {
+                  "@id" => "ex:Sub2",
+                  "@type" => "ex:Type2",
+                  "ex:includes" => {"@id" => "ex:Sub1"}
+                }
+              }
+            }]
+          }
+        },
+      }.each do |title, params|
+        it title do
+          @debug = []
+          begin
+            jld = JSON::LD::API.frame(params[:input], params[:frame], :debug => @debug)
+            expect(jld).to produce(params[:output], @debug)
+          rescue JSON::LD::JsonLdError, JSON::LD::JsonLdError, JSON::LD::InvalidFrame => e
+            fail("#{e.class}: #{e.message}\n" +
+              "#{@debug.join("\n")}\n" +
+              "Backtrace:\n#{e.backtrace.join("\n")}")
+          end
+        end
+      end
+    end
   end
 end