rdf-n3 0.2.1 → 0.2.2

data/spec/matchers.rb

@@ -1,17 +1,40 @@
+require 'rdf/isomorphic'
+
 module Matchers
   class BeEquivalentGraph
     Info = Struct.new(:about, :information, :trace, :compare, :inputDocument, :outputDocument)
     def normalize(graph)
-      case graph
-      when RDF::Graph then graph
-      when IO, StringIO
-        RDF::Graph.new.load(graph, :base_uri => @info.about)
+      case @info.compare
+      when :array
+        array = case graph
+        when RDF::Graph
+          raise ":compare => :array used with Graph"
+        when Array
+          graph.sort
+        else
+          graph.to_s.split("\n").
+            map {|t| t.gsub(/^\s*(.*)\s*$/, '\1')}.
+            reject {|t2| t2.match(/^\s*$/)}.
+            compact.
+            sort.
+            uniq
+        end
+        
+        # Implement to_ntriples on array, to simplify logic later
+        def array.to_ntriples; self.join("\n") + "\n"; end
+        array
       else
-        # Figure out which parser to use
-        g = RDF::Graph.new
-        reader_class = RDF::Reader.for(detect_format(graph))
-        reader_class.new(graph, :base_uri => @info.about).each {|s| g << s}
-        g
+        case graph
+        when RDF::Graph then graph
+        when IO, StringIO
+          RDF::Graph.new.load(graph, :base_uri => @info.about)
+        else
+          # Figure out which parser to use
+          g = RDF::Graph.new
+          reader_class = RDF::Reader.for(detect_format(graph))
+          reader_class.new(graph, :base_uri => @info.about).each {|s| g << s}
+          g
+        end
       end
     end
     
@@ -31,7 +54,11 @@ module Matchers
 
     def matches?(actual)
       @actual = normalize(actual)
-      @actual == @expected
+      if @info.compare == :array
+        @actual == @expected
+      else
+        @actual.isomorphic_with?(@expected)
+      end
     end
 
     def failure_message_for_should
@@ -48,6 +75,8 @@ module Matchers
       (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
       "Unsorted Expected:\n#{@expected.to_ntriples}" +
       "Unsorted Results:\n#{@actual.to_ntriples}" +
+#      "Unsorted Expected Dump:\n#{@expected.dump}\n" +
+#      "Unsorted Results Dump:\n#{@actual.dump}" +
       (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
     end
     def negative_failure_message

data/spec/n3reader_spec.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+$:.unshift "."
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe "RDF::N3::Reader" do
@@ -148,7 +149,6 @@ describe "RDF::N3::Reader" do
           statement = parse(n3).statements.first
           statement.object.value.should == "\u{15678}another"
         else
-          lambda { parse(n3) }.should raise_error(RDF::ReaderError, "Long Unicode escapes no supported in Ruby 1.8")
           pending("Not supported in Ruby 1.8")
         end
       end
@@ -267,17 +267,17 @@ describe "RDF::N3::Reader" do
         %(<#D%C3%BCrst>  a  "URI percent ^encoded as C3, BC".) => %(<http://a/b#D%C3%BCrst> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "URI percent ^encoded as C3, BC" .),
       }.each_pair do |n3, nt|
         it "for '#{n3}'" do
-          parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+          parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
         end
       end
 
       {
         %(<#Dürst>       a  "URI straight in UTF8".) => %(<http://a/b#D\\u00FCrst> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "URI straight in UTF8" .),
-        %(:a :related :\u3072\u3089\u304C\u306A.) => %(<http://a/b#a> <http://a/b#related> <http://a/b#\\u3072\\u3089\\u304C\\u306A> .),
+        #%(:a :related :ひらがな .) => %(<http://a/b#a> <http://a/b#related> <http://a/b#\\u3072\\u3089\\u304C\\u306A> .),
       }.each_pair do |n3, nt|
         it "for '#{n3}'" do
           begin
-            parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+            parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
           rescue
             if defined?(::Encoding)
               raise
@@ -289,7 +289,7 @@ describe "RDF::N3::Reader" do
       end
     end
     
-    it "should create URIRefs" do
+    it "should create URIs" do
       n3doc = "<http://example.org/joe> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> ."
       statement = parse(n3doc).statements.first
       statement.subject.class.should == RDF::URI
@@ -338,9 +338,9 @@ describe "RDF::N3::Reader" do
       it "should use <> as a prefix and as a triple node" do
         n3 = %(@prefix : <> . <> a :a.)
         nt = %(
-        <http://a/b> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://a/b#a> .
+        <http://a/b> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://a/ba> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should use <#> as a prefix and as a triple node" do
@@ -348,31 +348,31 @@ describe "RDF::N3::Reader" do
         nt = %(
         <http://a/b#> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://a/b#a> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should generate rdf:type for 'a'" do
         n3 = %(@prefix a: <http://foo/a#> . a:b a <http://www.w3.org/2000/01/rdf-schema#resource> .)
         nt = %(<http://foo/a#b> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#resource> .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should generate rdf:type for '@a'" do
         n3 = %(@prefix a: <http://foo/a#> . a:b @a <http://www.w3.org/2000/01/rdf-schema#resource> .)
         nt = %(<http://foo/a#b> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#resource> .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should generate inverse predicate for 'is xxx of'" do
         n3 = %("value" is :prop of :b . :b :prop "value"  .)
         nt = %(<http://a/b#b> <http://a/b#prop> "value" .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should generate inverse predicate for '@is xxx @of'" do
         n3 = %("value" @is :prop @of :b . :b :prop "value" .)
         nt = %(<http://a/b#b> <http://a/b#prop> "value" .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should generate inverse predicate for 'is xxx of' with object list" do
@@ -381,19 +381,19 @@ describe "RDF::N3::Reader" do
         <http://a/b#b> <http://a/b#prop> "value" .
         <http://a/b#c> <http://a/b#prop> "value" .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should generate predicate for 'has xxx'" do
         n3 = %(@prefix a: <http://foo/a#> . a:b has :pred a:c .)
         nt = %(<http://foo/a#b> <http://a/b#pred> <http://foo/a#c> .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should generate predicate for '@has xxx'" do
         n3 = %(@prefix a: <http://foo/a#> . a:b @has :pred a:c .)
         nt = %(<http://foo/a#b> <http://a/b#pred> <http://foo/a#c> .)
-          parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should create log:implies predicate for '=>'" do
@@ -433,13 +433,13 @@ describe "RDF::N3::Reader" do
       it "should accept empty localname" do
         n3 = %(: : : .)
         nt = %(<http://a/b#> <http://a/b#> <http://a/b#> .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should accept prefix with empty local name" do
         n3 = %(@prefix foo: <http://foo/bar#> . foo: foo: foo: .)
         nt = %(<http://foo/bar#> <http://foo/bar#> <http://foo/bar#> .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should do something for @forAll"
@@ -448,13 +448,37 @@ describe "RDF::N3::Reader" do
     end
     
     describe "namespaces" do
+      it "should not append # for http://foo/bar" do
+        n3 = %(@prefix : <http://foo/bar> . :a : :b .)
+        nt = %(
+        <http://foo/bara> <http://foo/bar> <http://foo/barb> .
+        )
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+      end
+
+      it "should not append # for http://foo/bar/" do
+        n3 = %(@prefix : <http://foo/bar/> . :a : :b .)
+        nt = %(
+        <http://foo/bar/a> <http://foo/bar/> <http://foo/bar/b> .
+        )
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+      end
+
+      it "should not append # for http://foo/bar#" do
+        n3 = %(@prefix : <http://foo/bar#> . :a : :b .)
+        nt = %(
+        <http://foo/bar#a> <http://foo/bar#> <http://foo/bar#b> .
+        )
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+      end
+
       it "should set absolute base" do
         n3 = %(@base <http://foo/bar> . <> :a <b> . <#c> :d </e>.)
         nt = %(
-        <http://foo/bar> <http://foo/bara> <http://foo/b> .
-        <http://foo/bar#c> <http://foo/bard> <http://foo/e> .
+        <http://foo/bar> <http://foo/bar#a> <http://foo/b> .
+        <http://foo/bar#c> <http://foo/bar#d> <http://foo/e> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should set absolute base (trailing /)" do
@@ -463,16 +487,16 @@ describe "RDF::N3::Reader" do
         <http://foo/bar/> <http://foo/bar/a> <http://foo/bar/b> .
         <http://foo/bar/#c> <http://foo/bar/d> <http://foo/e> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should set absolute base (trailing #)" do
         n3 = %(@base <http://foo/bar#> . <> :a <b> . <#c> :d </e>.)
         nt = %(
-        <http://foo/bar> <http://foo/bar#a> <http://foo/b> .
+        <http://foo/bar#> <http://foo/bar#a> <http://foo/b> .
         <http://foo/bar#c> <http://foo/bar#d> <http://foo/e> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should set relative base" do
@@ -492,7 +516,7 @@ describe "RDF::N3::Reader" do
         <http://example.org/products/> <http://example.org/products/a> <http://example.org/products/d> .
         <http://example.org/products/> <http://example.org/products/a> <http://example.org/products/#e> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
     end
     
@@ -522,7 +546,7 @@ describe "RDF::N3::Reader" do
         %(:c :a t)  => %(<http://a/b#c> <http://a/b#a> <http://a/b#t> .),
       }.each_pair do |n3, nt|
         it "should use default_ns for '#{n3}'" do
-          parse("@keywords . #{n3}", :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+          parse("@keywords . #{n3}", :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
         end
       end
 
@@ -535,7 +559,7 @@ describe "RDF::N3::Reader" do
         %(@keywords has. :a has :b :c.) => %(<http://a/b#a> <http://a/b#b> <http://a/b#c> .),
       }  .each_pair do |n3, nt|
           it "should use keyword for '#{n3}'" do
-            parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+            parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
           end
         end
       
@@ -573,7 +597,7 @@ describe "RDF::N3::Reader" do
         <http://host/A#b> <http://host/A#p> <http://host/A#v> .
         <http://host/Z#b> <http://host/Z#p> <http://host/Z#v> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
 
       it "should process sequential @base declarations (swap base.n3)" do
@@ -583,11 +607,11 @@ describe "RDF::N3::Reader" do
         @prefix : <#>. <d3> :b3 <e3>.
         )
         nt = %(
-        <http://example.com/a> <http://example.com/ontolgiesb> <http://example.com/foo/bar#baz> .
+        <http://example.com/a> <http://example.com/ontolgies#b> <http://example.com/foo/bar#baz> .
         <http://example.com/path/DFFERENT/a2> <http://example.com/path/DFFERENT/b2> <http://example.com/path/DFFERENT/foo/bar#baz2> .
         <http://example.com/path/DFFERENT/d3> <http://example.com/path/DFFERENT/#b3> <http://example.com/path/DFFERENT/e3> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
     end
     
@@ -600,13 +624,15 @@ describe "RDF::N3::Reader" do
       it "should create BNode for [] as subject" do
         n3 = %(@prefix a: <http://foo/a#> . [] a:p a:v .)
         nt = %(_:bnode0 <http://foo/a#p> <http://foo/a#v> .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+        g = parse(n3, :base_uri => "http://a/b")
+        normalize_bnodes(g, "bnode0").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
       end
       
       it "should create BNode for [] as predicate" do
         n3 = %(@prefix a: <http://foo/a#> . a:s [] a:o .)
         nt = %(<http://foo/a#s> _:bnode0 <http://foo/a#o> .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+        g = parse(n3, :base_uri => "http://a/b")
+        normalize_bnodes(g, "bnode0").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array, :anon => "bnode")
       end
       
       it "should create BNode for [] as object" do
@@ -785,7 +811,7 @@ describe "RDF::N3::Reader" do
         <http://foo/a#b> <http://foo/a#p2> <http://foo/a#v1> .
         <http://foo/a#b> <http://foo/a#p3> <http://foo/a#v2> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
     end
     
@@ -794,7 +820,7 @@ describe "RDF::N3::Reader" do
         n3 = %(@prefix :<http://example.com/>. :empty :set ().)
         nt = %(
         <http://example.com/empty> <http://example.com/set> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
       it "should parse list with single element" do
@@ -843,7 +869,7 @@ describe "RDF::N3::Reader" do
       it "should add property to nil list" do
         n3 = %(@prefix a: <http://foo/a#> . () a:prop "nilProp" .)
         nt = %(<http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://foo/a#prop> "nilProp" .)
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       it "should parse with compound items" do
         n3 = %(
@@ -857,21 +883,22 @@ describe "RDF::N3::Reader" do
         <http://resource1> a:p "value" .
         )
         nt = %(
-        _:bnode0 <http://foo/a#p2> "v1" .
-        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode0 .
-        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode2 .
-        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource1> .
-        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode3 .
-        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource2> .
-        _:bnode4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "inner list" .
-        _:bnode4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
-        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode5 .
+        <http://foo/a#a> <http://foo/a#p> _:bnode5 .
         _:bnode5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode4 .
-        _:bnode5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
-        <http://foo/a#a> <http://foo/a#p> _:bnode1 .
+        _:bnode5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode2 .
+        _:bnode4 <http://foo/a#p2> "v1" .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource1> .
         <http://resource1> <http://foo/a#p> "value" .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode1 .
+        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource2> .
+        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode0 .
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode3 .
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "inner list" .
+        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
         )
-        parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+        g = parse(n3, :base_uri => "http://a/b")
+        normalize_bnodes(g, "bnode0").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
       end
       
     end
@@ -971,7 +998,7 @@ EOF
 
     graph.should be_equivalent_graph(sampledoc,
       :about => "http://www.w3.org/2000/10/rdf-tests/rdfcore/amp-in-url/Manifest.rdf",
-      :trace => @debug, :compare => :array
+      :trace => @debug
     )
   end
   

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', 'rdf-rdfxml', 'lib'))
 $:.unshift File.dirname(__FILE__)
 
 require 'rubygems'
@@ -24,6 +25,13 @@ module RDF
         end
       end
     end
+    def dump
+      b = []
+      self.each_statement do |statement|
+        b << statement.to_triple.inspect
+      end
+      b.join("\n")
+    end
   end
 end
 
@@ -31,6 +39,21 @@ Spec::Runner.configure do |config|
   config.include(RDF::Spec::Matchers)
 end
 
+
+# Serialize graph and replace bnodes with predictable versions, return as sorted array  
+def normalize_bnodes(graph, anon = "a")
+  anon_ctx = {}
+  # Find and replace all BNodes within graph string
+  g_str = graph.to_ntriples
+  anon_entries = g_str.scan(/_:g\d+/).sort.uniq
+  anon_entries.each do |a|
+    anon_ctx[a] = "_:#{anon}"
+    anon = anon.succ
+  end
+  
+  g_str.gsub(/_:g\d+/) { |bn| anon_ctx[bn] }.split("\n").sort
+end
+
 # Heuristically detect the input stream
 def detect_format(stream)
   # Got to look into the file to see

data/spec/swap_spec.rb

@@ -1,3 +1,4 @@
+$:.unshift "."
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe RDF::N3::Reader do
@@ -42,6 +43,10 @@ describe RDF::N3::Reader do
               pending("check visually, graph compare times too long")
             elsif %w(n3_10010).include?(t.name)
               pending("Not supported in Ruby 1.8")
+            elsif %w(n3_10008 n3_10013).include?(t.name)
+              pending("Isomorphic compare issue")
+            elsif %w(n3_10016).include?(t.name)
+              pending("RDF.rb allows literal as predicate")
             else
               raise
             end
@@ -79,6 +84,8 @@ describe RDF::N3::Reader do
                 pending("formulae not yet implemented")
               elsif %w(n3_20000).include?(t.name)
                 pending("figure out how to tell that these are errors")
+              elsif %w(n3_20004).include?(t.name)
+                pending("RDF.rb allows literal as predicate")
               else
                 raise
               end