Look at @reverse when generating RDF.

Author: gkellogg

lib/json/ld/to_rdf.rb

@@ -21,7 +21,7 @@ def item_to_rdf(item, graph_name: nil, &block)
           # If value is true or false, then set value its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to xsd:boolean.
           value = value.to_s
           datatype ||= RDF::XSD.boolean.to_s
-        when Float, Fixnum
+        when Integer, Float, Fixnum
           # Otherwise, if value is a number, then set value to its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
           lit = RDF::Literal.new(value, canonicalize: true)
           value = lit.to_s
@@ -49,10 +49,33 @@ def item_to_rdf(item, graph_name: nil, &block)
             yield RDF::Statement(subject, RDF.type, object, graph_name: graph_name)
           end
         when '@graph'
-          # Values are nodes using our subject as the graph name
+          values = [values].compact unless values.is_a?(Array)
           values.each do |nd|
             item_to_rdf(nd, graph_name: subject, &block)
           end
+        when '@reverse'
+          raise "Huh?" unless values.is_a?(Hash)
+          values.each do |prop, vv|
+            predicate = as_resource(prop)
+            log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+            # For each item in values
+            vv.each do |v|
+              if list?(v)
+                log_debug("item_to_rdf")  {"list: #{v.inspect}"}
+                # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
+                object = parse_list(v['@list'], graph_name: graph_name, &block)
+
+                # Append a triple composed of object, prediate, and object to results and add all triples from list_results to results.
+                yield RDF::Statement(object, predicate, subject, graph_name: graph_name)
+              else
+                # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
+                object = item_to_rdf(v, graph_name: graph_name, &block)
+                log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
+                # yield subject, prediate, and literal to results.
+                yield RDF::Statement(object, predicate, subject, graph_name: graph_name)
+              end
+            end
+          end
         when /^@/
           # Otherwise, if @type is any other keyword, skip to the next property-values pair
         else

spec/suite_helper.rb

@@ -115,17 +115,19 @@ def run(rspec_example = nil)
               logger.info "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
               JSON::LD::API.fromRdf(repo, options.merge(logger: logger))
             when "jld:ToRDFTest"
-              JSON::LD::API.toRdf(input_loc, options.merge(logger: logger)).map do |statement|
-                to_quad(statement)
+              repo = RDF::Repository.new
+              JSON::LD::API.toRdf(input_loc, options.merge(logger: logger)) do |statement|
+                repo << statement
               end
+              repo
             else
               fail("Unknown test type: #{testType}")
             end
             if evaluationTest?
               if testType == "jld:ToRDFTest"
-                expected = expect
+                expected = RDF::Repository.new << RDF::NQuads::Reader.new(expect)
                 rspec_example.instance_eval {
-                  expect(result.sort.join("")).to produce(expected, logger)
+                  expect(result).to be_equivalent_graph(expected, logger)
                 }
               else
                 expected = JSON.load(expect)
@@ -163,9 +165,7 @@ def run(rspec_example = nil)
                   logger.info "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
                   JSON::LD::API.fromRdf(repo, options.merge(logger: logger))
                 when "jld:ToRDFTest"
-                  JSON::LD::API.toRdf(t.input_loc, options.merge(logger: logger)).map do |statement|
-                    t.to_quad(statement)
-                  end
+                  JSON::LD::API.toRdf(t.input_loc, options.merge(logger: logger)) {}
                 else
                   success("Unknown test type: #{testType}")
                 end

spec/suite_to_rdf_spec.rb

@@ -9,6 +9,9 @@
     describe m.name do
       m.entries.each do |t|
         specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
+          skip "Native value fidelity" if %w(toRdf-0035-in.jsonld).include?(t.property('input'))
+          pending "Generalized RDF" if %w(toRdf-0118-in.jsonld).include?(t.property('input'))
+          pending "Blank nodes with reverse properties" if %w(toRdf-0119-in.jsonld).include?(t.property('input'))
           t.run self
         end
       end