rdf-spec 1.0.9 → 1.1.0.p1

data/etc/doap.ttl

@@ -0,0 +1,79 @@
+@base         <http://rubygems.org/gems/rdf> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix dc:   <http://purl.org/dc/terms/> .
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix doap: <http://usefulinc.com/ns/doap#> .
+
+<> a doap:Project ;
+  doap:name          "RDF.rb" ;
+  doap:homepage      <http://rubygems.org/gems/rdf> ;
+  doap:license       <http://creativecommons.org/licenses/publicdomain/> ;
+  doap:shortdesc     "A Ruby library for working with Resource Description Framework (RDF) data."@en ;
+  doap:description   "RDF.rb is a pure-Ruby library for working with Resource Description Framework (RDF) data."@en ;
+  doap:created       "2007-10-23" ;
+  doap:platform      "Ruby" ;
+  doap:category      <http://dbpedia.org/resource/Resource_Description_Framework>,
+                     <http://dbpedia.org/resource/Ruby_(programming_language)> ;
+  doap:implements    <http://www.w3.org/TR/rdf-concepts/>,
+                     <http://sw.deri.org/2008/07/n-quads/>,
+                     <http://www.w3.org/2001/sw/RDFCore/ntriples/> ;
+  doap:download-page <http://rubyforge.org/projects/rdf/> ;
+  doap:bug-database  <http://github.com/ruby-rdf/rdf/issues> ;
+  doap:blog          <http://ar.to/>, <http://blog.datagraph.org/> ;
+  doap:vendor        <http://datagraph.org/> ;
+  doap:developer     <http://ar.to/#self>, <http://bhuga.net/#ben>, <http://greggkellogg.net/foaf#me> ;
+  doap:maintainer    <http://ar.to/#self>, <http://bhuga.net/#ben>, <http://greggkellogg.net/foaf#me> ;
+  doap:documenter    <http://ar.to/#self>, <http://bhuga.net/#ben>, <http://greggkellogg.net/foaf#me> ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "Călin Ardelean" ;
+                      foaf:mbox_sha1sum "274bd18402fc773ffc0606996aa1fb90b603aa29"] ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "Danny Gagne" ;
+                      foaf:mbox_sha1sum "6de43e9cf7de53427fea9765706703e4d957c17b"] ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "Joey Geiger" ;
+                      foaf:mbox_sha1sum "f412d743150d7b27b8468d56e69ca147917ea6fc"] ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "Fumihiro Kato" ;
+                      foaf:mbox_sha1sum "d31fdd6af7a279a89bf09fdc9f7c44d9d08bb930"] ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "Naoki Kawamukai" ;
+                      foaf:mbox_sha1sum "5bdcd8e2af4f5952aaeeffbdd371c41525ec761d"] ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "Hellekin O. Wolf" ;
+                      foaf:mbox_sha1sum "c69f3255ff0639543cc5edfd8116eac8df16fab8"] ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "John Fieber" ;
+                      foaf:mbox_sha1sum "f7653fc1ac0e82ebb32f092389bd5fc728eaae12"] ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "Keita Urashima" ;
+                      foaf:mbox_sha1sum "2b4247b6fd5bb4a1383378f325784318680d5ff9"] ;
+  doap:helper        [a foaf:Person ;
+                      foaf:name "Pius Uzamere" ;
+                      foaf:mbox_sha1sum "bedbbf2451e5beb38d59687c0460032aff92cd3c"] ;
+  foaf:maker         <http://ar.to/#self> ;
+  dc:creator         <http://ar.to/#self> .
+
+<http://ar.to/#self> a foaf:Person ;
+  foaf:name          "Arto Bendiken" ;
+  foaf:mbox          <mailto:arto.bendiken@gmail.com> ;
+  foaf:mbox_sha1sum  "d0737cceb55eb7d740578d2db1bc0727e3ed49ce",
+                     "a033f652c84a4d73b8c26d318c2395699dd2bdfb" ;
+  foaf:homepage      <http://ar.to/> ;
+  foaf:made          <> ;
+  rdfs:isDefinedBy   <http://datagraph.org/bendiken/foaf> .
+
+<http://bhuga.net/#ben> a foaf:Person ;
+  foaf:name          "Ben Lavender" ;
+  foaf:mbox          <mailto:blavender@gmail.com> ;
+  foaf:mbox_sha1sum  "dbf45f4ffbd27b67aa84f02a6a31c144727d10af" ;
+  foaf:homepage      <http://bhuga.net/> ;
+  rdfs:isDefinedBy   <http://datagraph.org/bhuga/foaf> .
+
+<http://greggkellogg.net/foaf#me> a foaf:Person ;
+  foaf:name          "Gregg Kellogg" ;
+  foaf:mbox          <mailto:gregg@greggkellogg.net> ;
+  foaf:mbox_sha1sum  "35bc44e6d0070e5ad50ccbe0d24403c96af2b9bd" ;
+  foaf:homepage      <http://greggkellogg.net/>;
+  rdfs:isDefinedBy   <http://greggkellogg.net/foaf> .

data/etc/gkellogg.nq

@@ -1,6 +1,5 @@
-<http://greggkellogg.net/foaf#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> <http://greggkellogg.net/foaf#me> .
-<http://greggkellogg.net/foaf#me> <http://xmlns.com/foaf/0.1/name> "Gregg Kellogg" <http://greggkellogg.net/foaf#me> .
-<http://greggkellogg.net/foaf#me> <http://xmlns.com/foaf/0.1/mbox> <mailto:gregg@greggkellogg.net> <http://greggkellogg.net/foaf#me> .
-<http://greggkellogg.net/foaf#me> <http://xmlns.com/foaf/0.1/mbox_sha1sum> "35bc44e6d0070e5ad50ccbe0d24403c96af2b9bd" <http://greggkellogg.net/foaf#me> .
-<http://greggkellogg.net/foaf#me> <http://xmlns.com/foaf/0.1/homepage> <http://greggkellogg.net/> <http://greggkellogg.net/foaf#me> .
-<http://greggkellogg.net/foaf#me> <http://www.w3.org/2000/01/rdf-schema#isDefinedBy> <http://greggkellogg.net/foaf> <http://greggkellogg.net/foaf#me> .
+<http://greggkellogg.net/#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person>  <http://greggkellogg.net/#me> .
+<http://greggkellogg.net/#me> <http://xmlns.com/foaf/0.1/name> "Gregg Kellogg"  <http://greggkellogg.net/#me> .
+<http://greggkellogg.net/#me> <http://xmlns.com/foaf/0.1/mbox> <mailto:gregg@greggkellogg.net>  <http://greggkellogg.net/#me> .
+<http://greggkellogg.net/#me> <http://xmlns.com/foaf/0.1/mbox_sha1sum> "b7a856d39fc3f02573271d9901f1f9107147f657"  <http://greggkellogg.net/#me> .
+<http://greggkellogg.net/#me> <http://xmlns.com/foaf/0.1/homepage> <http://greggkellogg.net/>  <http://greggkellogg.net/#me> .

data/etc/gkellogg.nt

@@ -0,0 +1,5 @@
+<http://greggkellogg.net/#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+<http://greggkellogg.net/#me> <http://xmlns.com/foaf/0.1/name> "Gregg Kellogg" .
+<http://greggkellogg.net/#me> <http://xmlns.com/foaf/0.1/mbox> <mailto:gregg@greggkellogg.net> .
+<http://greggkellogg.net/#me> <http://xmlns.com/foaf/0.1/mbox_sha1sum> "b7a856d39fc3f02573271d9901f1f9107147f657" .
+<http://greggkellogg.net/#me> <http://xmlns.com/foaf/0.1/homepage> <http://greggkellogg.net/> .

data/etc/gkellogg.ttl

@@ -0,0 +1,14 @@
+@base         <http://rubygems.org/gems/rdf> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix dc:   <http://purl.org/dc/terms/> .
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix doap: <http://usefulinc.com/ns/doap#> .
+@prefix ex:   <http://example.org/> .
+@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
+
+<http://greggkellogg.net/#me> a foaf:Person ;
+  foaf:name          "Gregg Kellogg" ;
+  foaf:mbox          <mailto:gregg@greggkellogg.net> ;
+  foaf:mbox_sha1sum  "b7a856d39fc3f02573271d9901f1f9107147f657" ;
+  foaf:homepage      <http://greggkellogg.net/> .

data/etc/test-data.nt

@@ -1,3 +1,4 @@
+# Test data from SPARQLdata-r2/expr-equals
 <http://example.org/xi1> <http://example.org/p> "1"^^<http://www.w3.org/2001/XMLSchema#integer> .
 <http://example.org/xi2> <http://example.org/p> "1"^^<http://www.w3.org/2001/XMLSchema#integer> .
 <http://example.org/xi3> <http://example.org/p> "01"^^<http://www.w3.org/2001/XMLSchema#integer> .

data/lib/rdf/spec.rb

@@ -46,25 +46,5 @@ module RDF
   module Spec
     autoload :Matchers, 'rdf/spec/matchers'
     autoload :VERSION,  'rdf/spec/version'
-    TRIPLES_FILE = File.expand_path("../../../etc/triples.nt", __FILE__)
-    QUADS_FILE = File.expand_path("../../../etc/quads.nq", __FILE__)
-
-    ##
-    # Return quads for tests
-    #
-    # @return [Array<RDF::Statement>]
-    def self.quads
-      require 'rdf/nquads'
-      (@quads ||=  RDF::NQuads::Reader.new(File.open(QUADS_FILE)).to_a).dup
-    end
-
-    ##
-    # Return triples for tests
-    #
-    # @return [Array<RDF::Statement>]
-    def self.triples
-      require 'rdf/ntriples'
-      (@triples ||=  RDF::NTriples::Reader.new(File.open(TRIPLES_FILE)).to_a).dup
-    end
   end # Spec
 end # RDF

data/lib/rdf/spec/countable.rb

@@ -7,38 +7,43 @@ module RDF_Countable
   before :each do
     raise '+@countable+ must be defined in a before(:each) block' unless instance_variable_get('@countable')
 
-    @statements = RDF::Spec.quads
+    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
+    @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
 
     if @countable.empty?
-      if @countable.respond_to?(:<<) && (@countable.writable? rescue true)
+      if @countable.respond_to?(:<<)
         @statements.each { |statement| @countable << statement }
       else
-        raise "+@countable+ must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
+        raise "+@countable+ must respond to #<< or be pre-populated with the statements in #{@filename} in a before(:each) block"
       end
     end
   end
 
   describe RDF::Countable do
-    subject {@countable}
-
-    it {should respond_to(:empty?)}
-    it {should_not be_empty}
-    it {should respond_to(:count)}
-    its(:count) {should == @statements.size}
-    it {should respond_to(:size)}
-    its(:size) {should == @statements.size}
-
-    context "when empty" do
-      subject {[].extend(RDF::Countable)}
-      it {should be_empty}
-      its(:count) {should == 0}
-      its(:size) {should == 0}
+    it "responds to #empty?" do
+      @countable.should respond_to(:empty?)
     end
 
-    its(:to_enum) {should be_countable}
-    its(:enum_for) {should be_countable}
-    it "#enum_for(:each)" do
-      expect(subject.enum_for(:each)).to be_countable
+    it "responds to #count and #size" do
+      @countable.should respond_to(:count, :size)
+    end
+
+    it "implements #empty?" do
+      ([].extend(RDF::Countable)).empty?.should be_true
+      ([42].extend(RDF::Countable)).empty?.should be_false
+      @countable.empty?.should be_false
+    end
+
+    it "implements #count and #size" do
+      %w(count size).each do |method|
+        @countable.send(method).should >= @statements.size
+      end
+    end
+
+    it "returns countable enumerators" do
+      @countable.to_enum.should be_countable
+      @countable.enum_for.should be_countable
+      @countable.enum_for(:each).should be_countable
     end
   end
 end

data/lib/rdf/spec/durable.rb

@@ -23,25 +23,29 @@ module RDF_Durable
 
   before :each do
     raise '+@load_durable+ must be defined in a before(:each) block' unless instance_variable_get('@load_durable')
+    # RDF::Queryable cares about the contents of this file too much to let someone set it
+    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
   end
 
   describe RDF::Durable do
-    subject {@load_durable.call}
-    it {should respond_to(:durable?)}
     it "should support #durable?" do
-      expect([true,false]).to be_member(subject.durable?)
+      @load_durable.call.should respond_to(:durable?)
+      [true,false].member?(@load_durable.call.durable?).should be_true
     end
 
-    it {should respond_to(:nondurable?)}
     it "should support #nondurable?" do
-      expect([true,false]).to be_member(@load_durable.call.nondurable?)
+      @load_durable.call.should respond_to(:nondurable?)
+      [true,false].member?(@load_durable.call.nondurable?).should be_true
+    end
+
+    it "should not be both durable and nondurable" do
+      @load_durable.call.nondurable?.should_not == @load_durable.call.durable?
     end
-    its(:nondurable?) {should_not == subject.durable?}
 
     it "should save contents between instantiations" do
-      if subject.durable?
-       subject.load(RDF::Spec::TRIPLES_FILE)
-       expect(subject.count).to eq File.readlines(RDF::Spec::TRIPLES_FILE).size
+      if @load_durable.call.durable?
+        @load_durable.call.load(@filename)
+        @load_durable.call.count.should == File.readlines(@filename).size
       end
     end
   end

data/lib/rdf/spec/enumerable.rb

@@ -7,36 +7,38 @@ module RDF_Enumerable
   before :each do
     raise '+@enumerable+ must be defined in a before(:each) block' unless instance_variable_get('@enumerable')
 
-    @statements ||= RDF::Spec.quads
+    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
+    @statements ||= RDF::NTriples::Reader.new(File.open(@filename)).to_a
 
     if @enumerable.empty?
-      if @enumerable.respond_to?(:<<) && (@enumerable.writable? rescue true)
+      if @enumerable.respond_to?(:<<)
         @statements.each { |statement| @enumerable << statement }
       else
-        raise "@enumerable must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
+        raise "@enumerable must respond to #<< or be pre-populated with the statements in #{@filename} in a before(:each) block"
       end
     end
 
-    @supports_context = @enumerable.supports?(:context) rescue true
+    @supports_context = @enumerable.respond_to?(:supports?) && @enumerable.supports?(:context)
   end
 
   describe RDF::Enumerable do
-    let(:subject_count) {@statements.map(&:subject).uniq.length}
-    let(:bnode_subject_count) {@statements.map(&:subject).uniq.select(&:node?).length}
-    let(:non_bnode_statements) {@statements.reject {|s| s.subject.node? || s.object.node?}}
-
-    subject {@enumerable}
-    it {should respond_to(:supports?)}
+    describe "#supports?" do
+      it "responds to #supports?" do
+        @enumerable.respond_to?(:support?)
+      end
+    end
 
     describe "valid?" do
-      it {should be_valid}
+      it "returns true if all statements are valid" do
+        @enumerable.should be_valid
+      end
       
       it "returns false if any statement is invalid" do
-        if subject.respond_to?(:<<) && (subject.writable? rescue true)
+        if @enumerable.respond_to?(:<<)
           s = RDF::Statement.from([nil, nil, nil])
-          expect(s).not_to  be_valid
-          subject << s
-          expect(subject).not_to  be_valid
+          s.should_not be_valid
+          @enumerable << s
+          @enumerable.should_not be_valid
         else
           pending("can't add statement to immutable enumerable")
         end
@@ -44,383 +46,431 @@ module RDF_Enumerable
     end
 
     context "when counting statements" do
-      it {should respond_to(:empty?)}
-      it {should_not be_empty}
-      it {should respond_to(:count)}
-      its(:count) {should == @statements.size}
-      it {should respond_to(:size)}
-      its(:size) {should == @statements.size}
-
-      context "and empty" do
-        subject {[].extend(RDF::Enumerable)}
-        it {should be_empty}
-        its(:count) {should == 0}
-        its(:size) {should == 0}
+      it "should respond to #empty?" do
+        @enumerable.should respond_to(:empty?)
+      end
+
+      it "should respond to #count and #size" do
+        @enumerable.should respond_to(*%w(count size))
+      end
+
+      it "should implement #empty?" do
+        ([].extend(RDF::Enumerable)).empty?.should be_true
+        @enumerable.empty?.should be_false
+      end
+
+      it "should implement #count and #size" do
+        %w(count size).each do |method|
+          @enumerable.send(method).should == @statements.size
+        end
       end
     end
 
     context "when enumerating statements" do
-      it {should respond_to(:statements)}
-      its(:statements) {should be_an_enumerator}
+      it "should respond to #statements" do
+        @enumerable.should respond_to(:statements)
+      end
 
-      context "#statements" do
-        specify {expect(subject.statements.to_a.size).to eq @statements.size}
-        specify {subject.statements.each { |statement| expect(statement).to be_a_statement }}
+      it "should respond to #has_statement?" do
+        @enumerable.should respond_to(:has_statement?)
       end
 
-      it {should respond_to(:has_statement?)}
-      context "#has_statement?" do
-        let(:unknown_statement) {RDF::Statement.new(RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new)}
-        it "should have all statements" do
-          # Don't check for BNodes, as equivalence depends on their being exactly the same, not just the same identifier. If subject is loaded separately, these won't match.
-          non_bnode_statements.each do |statement|
-            expect(subject).to have_statement(statement)
-          end
+      it "should respond to #each_statement" do
+        @enumerable.should respond_to(:each_statement)
+      end
+
+      it "should respond to #enum_statement" do
+        @enumerable.should respond_to(:enum_statement)
+      end
+
+      it "should implement #statements" do
+        @enumerable.statements.should be_an_enumerator
+        @enumerable.statements.to_a.size.should == @statements.size
+        @enumerable.statements.each { |statement| statement.should be_a_statement }
+      end
+
+      it "should implement #has_statement?" do
+        @statements.each do |statement|
+          @enumerable.has_statement?(statement).should be_true
         end
 
-        it "does not have statement in different context" do
-          if @supports_context
-            context = RDF::URI.new("urn:context:1")
-            non_bnode_statements.each do |statement|
-              s = statement.dup
-              s.context = context
-              expect(subject).not_to have_statement(s)
-            end
+        if @supports_context
+          context = RDF::URI.new("urn:context:1")
+          @statements.each do |statement|
+            s = statement.dup
+            s.context = context
+            @enumerable.has_statement?(s).should be_false
           end
         end
 
-        it "does not have an unknown statement" do
-          expect(subject).not_to have_statement(unknown_statement)
-        end
+        unknown_statement = RDF::Statement.new(RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new)
+        @enumerable.has_statement?(unknown_statement).should be_false
       end
 
-      it {should respond_to(:each_statement)}
-      its(:each_statement) {should be_an_enumerator}
       it "should implement #each_statement" do
-        subject.each_statement { |statement| expect(statement).to be_a_statement }
+        @enumerable.each_statement.should be_an_enumerator
+        @enumerable.each_statement { |statement| statement.should be_a_statement }
       end
 
-      it {should respond_to(:enum_statement)}
-      its(:enum_statement) {should be_an_enumerator}
-      its(:enum_statement) {should be_countable}
-      its(:enum_statement) {should be_enumerable}
-      its(:enum_statement) {should be_queryable}
-      context "#enum_statement" do
-        it "should enumerate all statements" do
-          expect(subject.enum_statement.to_a).to include(*@enumerable.each_statement.to_a)
-        end
+      it "should implement #enum_statement" do
+        @enumerable.enum_statement.should be_an_enumerator
+        @enumerable.enum_statement.should be_countable
+        @enumerable.enum_statement.should be_enumerable
+        @enumerable.enum_statement.should be_queryable
+        @enumerable.enum_statement.to_a.should == @enumerable.each_statement.to_a
       end
     end
 
     context "when enumerating triples" do
-      it {should respond_to(:triples)}
-      it {should respond_to(:has_triple?)}
-      it {should respond_to(:each_triple)}
-      it {should respond_to(:enum_triple)}
+      it "should respond to #triples" do
+        @enumerable.should respond_to(:triples)
+      end
 
-      its(:triples) {should be_an_enumerator}
-      context "#triples" do
-        specify {expect(subject.triples.to_a.size).to eq @statements.size}
-        specify {subject.triples.each { |triple| expect(triple).to be_a_triple }}
+      it "should respond to #has_triple?" do
+        @enumerable.should respond_to(:has_triple?)
       end
 
-      context "#has_triple?" do
-        specify do
-          non_bnode_statements.each do |statement|
-            expect(subject).to have_triple(statement.to_triple)
-          end
-        end
+      it "should respond to #each_triple" do
+        @enumerable.should respond_to(:each_triple)
       end
 
-      its(:each_triple) {should be_an_enumerator}
-      context "#each_triple" do
-        specify {subject.each_triple { |*triple| expect(triple).to be_a_triple }}
+      it "should respond to #enum_triple" do
+        @enumerable.should respond_to(:enum_triple)
       end
 
-      its(:enum_triple) {should be_an_enumerator}
-      its(:enum_triple) {should be_countable}
-      context "#enum_triple" do
-        it "should enumerate all triples" do
-          expect(subject.enum_triple.to_a).to include(*@enumerable.each_triple.to_a)
+      it "should implement #triples" do
+        @enumerable.triples.should be_an_enumerator
+        @enumerable.triples.to_a.size.should == @statements.size
+        @enumerable.triples.each { |triple| triple.should be_a_triple }
+      end
+
+      it "should implement #has_triple?" do
+        @statements.each do |statement|
+          @enumerable.has_triple?(statement.to_triple).should be_true
         end
       end
+
+      it "should implement #each_triple" do
+        @enumerable.each_triple.should be_an_enumerator
+        @enumerable.each_triple { |*triple| triple.should be_a_triple }
+      end
+
+      it "should implement #enum_triple" do
+        @enumerable.enum_triple.should be_an_enumerator
+        @enumerable.enum_triple.should be_countable
+        @enumerable.enum_triple.to_a.should == @enumerable.each_triple.to_a
+      end
     end
 
     context "when enumerating quads" do
-      it {should respond_to(:quads)}
-      it {should respond_to(:has_quad?)}
-      it {should respond_to(:each_quad)}
-      it {should respond_to(:enum_quad)}
-
-      its(:quads) {should be_an_enumerator}
-      context "#quads" do
-        specify {expect(subject.quads.to_a.size).to eq @statements.size}
-        specify {subject.quads.each { |quad| expect(quad).to be_a_quad }}
-      end
-
-      context "#has_quad?" do
-        specify do
-          if @supports_context
-            non_bnode_statements.each do |statement|
-              expect(subject).to have_quad(statement.to_quad)
-            end
-          end
-        end
+      it "should respond to #quads" do
+        @enumerable.should respond_to(:quads)
+      end
+
+      it "should respond to #has_quad?" do
+        @enumerable.should respond_to(:has_quad?)
+      end
+
+      it "should respond to #each_quad" do
+        @enumerable.should respond_to(:each_quad)
+      end
+
+      it "should respond to #enum_quad" do
+        @enumerable.should respond_to(:enum_quad)
       end
 
-      its(:each_quad) {should be_an_enumerator}
-      context "#each_quad" do
-        specify {subject.each_quad {|*quad| expect(quad).to be_a_quad }}
+      it "should implement #quads" do
+        @enumerable.quads.should be_an_enumerator
+        @enumerable.quads.to_a.size.should == @statements.size
+        @enumerable.quads.each { |quad| quad.should be_a_quad }
       end
 
-      its(:enum_quad) {should be_an_enumerator}
-      its(:enum_quad) {should be_countable}
-      context "#enum_quad" do
-        it "should enumerate all quads" do
-          expect(subject.enum_quad.to_a).to include(*@enumerable.each_quad.to_a)
+      it "should implement #has_quad?" do
+        @statements.each do |statement|
+          @enumerable.has_quad?(statement.to_quad).should be_true
         end
       end
+
+      it "should implement #each_quad" do
+        @enumerable.each_quad.should be_an_enumerator
+        @enumerable.each_quad { |*quad| quad.should be_a_quad }
+      end
+
+      it "should implement #enum_quad" do
+        @enumerable.enum_quad.should be_an_enumerator
+        @enumerable.enum_quad.should be_countable
+        @enumerable.enum_quad.to_a.should == @enumerable.each_quad.to_a
+      end
     end
 
     context "when enumerating subjects" do
-      let(:subjects) {subject.map { |s| s.subject }.reject(&:node?).uniq}
-      it {should respond_to(:subjects)}
-      it {should respond_to(:has_subject?)}
-      it {should respond_to(:each_subject)}
-      it {should respond_to(:enum_subject)}
-
-      its(:subjects) {should be_an_enumerator}
-      context "#subjects" do
+      it "should respond to #subjects" do
+        @enumerable.should respond_to(:subjects)
+      end
+
+      it "should respond to #has_subject?" do
+        @enumerable.should respond_to(:has_subject?)
+      end
+
+      it "should respond to #each_subject" do
+        @enumerable.should respond_to(:each_subject)
+      end
+
+      it "should respond to #enum_subject" do
+        @enumerable.should respond_to(:enum_subject)
+      end
+
+      describe "#subjects" do
         subject {@enumerable.subjects}
-        specify {expect(subject).to be_an_enumerator}
-        specify {subject.each { |value| expect(value).to be_a_resource }}
+        specify {subject.should be_an_enumerator}
+        specify {subject.each { |value| value.should be_a_resource }}
         context ":unique => false" do
           subject {@enumerable.subjects(:unique => false)}
-          specify {expect(subject).to be_an_enumerator}
-          specify {subject.each { |value| expect(value).to be_a_resource }}
+          specify {subject.should be_an_enumerator}
+          specify {subject.each { |value| value.should be_a_resource }}
         end
       end
 
-      context "#has_subject?" do
-        specify do
-          checked = []
-          non_bnode_statements.each do |statement|
-            expect(@enumerable).to have_subject(statement.subject) unless checked.include?(statement.subject)
-            checked << statement.subject
-          end
-          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-          expect(@enumerable).not_to have_subject(uri)
+      it "should implement #has_subject?" do
+        checked = []
+        @statements.each do |statement|
+          @enumerable.has_subject?(statement.subject).should be_true unless checked.include?(statement.subject)
+          checked << statement.subject
         end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        @enumerable.has_predicate?(uri).should be_false
       end
 
-      its(:each_subject) {should be_an_enumerator}
-      context "#each_subject" do
-        specify {expect(subject.each_subject.reject(&:node?).size).to eq subjects.size}
-        specify {subject.each_subject {|value| expect(value).to be_a_resource}}
-        specify {subject.each_subject {|value| expect(subjects).to include(value) unless value.node?}}
+      it "should implement #each_subject" do
+        @enumerable.each_subject.should be_an_enumerator
+        subjects = @statements.map { |s| s.subject }.uniq
+        @enumerable.each_subject.to_a.size.should == subjects.size
+        @enumerable.each_subject do |value|
+          value.should be_a_value
+          subjects.should include(value)
+        end
       end
 
-      its(:enum_subject) {should be_an_enumerator}
-      its(:enum_subject) {should be_countable}
-      context "#enum_subject" do
-        it "should enumerate all subjects" do
-          expect(subject.enum_subject.reject(&:node?)).to include(*subjects)
-        end
+      it "should implement #enum_subject" do
+        @enumerable.enum_subject.should be_an_enumerator
+        @enumerable.enum_subject.should be_countable
+        @enumerable.enum_subject.to_a.should == @enumerable.each_subject.to_a
       end
     end
 
     context "when enumerating predicates" do
-      let(:predicates) {@statements.map { |s| s.predicate }.uniq}
-      it {should respond_to(:predicates)}
-      it {should respond_to(:has_predicate?)}
-      it {should respond_to(:each_predicate)}
-      it {should respond_to(:enum_predicate)}
-
-      its(:predicates) {should be_an_enumerator}
-      context "#predicates" do
+      it "should respond to #predicates" do
+        @enumerable.should respond_to(:predicates)
+      end
+
+      it "should respond to #has_predicate?" do
+        @enumerable.should respond_to(:has_predicate?)
+      end
+
+      it "should respond to #each_predicate" do
+        @enumerable.should respond_to(:each_predicate)
+      end
+
+      it "should respond to #enum_predicate" do
+        @enumerable.should respond_to(:enum_predicate)
+      end
+
+      describe "#predicates" do
         subject {@enumerable.predicates}
-        specify {expect(subject).to be_an_enumerator}
-        specify {subject.each { |value| expect(value).to be_a_uri }}
+        specify {subject.should be_an_enumerator}
+        specify {subject.each { |value| value.should be_a_uri }}
         context ":unique => false" do
           subject {@enumerable.predicates(:unique => false)}
-          specify {expect(subject).to be_an_enumerator}
-          specify {subject.each { |value| expect(value).to be_a_uri }}
+          specify {subject.should be_an_enumerator}
+          specify {subject.each { |value| value.should be_a_resource }}
         end
       end
 
-      context "#has_predicate?" do
-        specify do
-          checked = []
-          @statements.each do |statement|
-            expect(@enumerable).to have_predicate(statement.predicate) unless checked.include?(statement.predicate)
-            checked << statement.predicate
-          end
-          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-          expect(@enumerable).not_to have_predicate(uri)
+      it "should implement #has_predicate?" do
+        checked = []
+        @statements.each do |statement|
+          @enumerable.has_predicate?(statement.predicate).should be_true unless checked.include?(statement.object)
+          checked << statement.predicate
         end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        @enumerable.has_predicate?(uri).should be_false
       end
 
-      its(:each_predicate) {should be_an_enumerator}
-      context "#each_predicate" do
-        specify {expect(subject.each_predicate.to_a.size).to eq predicates.size}
-        specify {subject.each_predicate {|value| expect(value).to be_a_uri}}
-        specify {subject.each_predicate {|value| expect(predicates).to include(value)}}
+      it "should implement #each_predicate" do
+        predicates = @statements.map { |s| s.predicate }.uniq
+        @enumerable.each_predicate.should be_an_enumerator
+        @enumerable.each_predicate.to_a.size.should == predicates.size
+        @enumerable.each_predicate do |value|
+          value.should be_a_uri
+          predicates.should include(value)
+        end
       end
 
-      its(:enum_predicate) {should be_an_enumerator}
-      its(:enum_predicate) {should be_countable}
-      context "#enum_predicate" do
-        it "should enumerate all predicates" do
-          expect(subject.enum_predicate.to_a).to include(*predicates)
-        end
+      it "should implement #enum_predicate" do
+        @enumerable.enum_predicate.should be_an_enumerator
+        @enumerable.enum_predicate.should be_countable
+        @enumerable.enum_predicate.to_a.should == @enumerable.each_predicate.to_a
       end
     end
 
     context "when enumerating objects" do
-      let(:objects) {subject.map(&:object).reject(&:node?).uniq}
-      it {should respond_to(:objects)}
-      it {should respond_to(:has_object?)}
-      it {should respond_to(:each_object)}
-      it {should respond_to(:enum_object)}
-
-      its(:objects) {should be_an_enumerator}
-      context "#objects" do
+      it "should respond to #objects" do
+        @enumerable.should respond_to(:objects)
+      end
+
+      it "should respond to #has_object?" do
+        @enumerable.should respond_to(:has_object?)
+      end
+
+      it "should respond to #each_object" do
+        @enumerable.should respond_to(:each_object)
+      end
+
+      it "should respond to #enum_object" do
+        @enumerable.should respond_to(:enum_object)
+      end
+
+      describe "#objects" do
         subject {@enumerable.objects}
-        specify {expect(subject).to be_an_enumerator}
-        specify {subject.each { |value| expect(value).to be_a_term }}
+        specify {subject.should be_an_enumerator}
+        specify {subject.each { |value| value.should be_a_value }}
         context ":unique => false" do
           subject {@enumerable.objects(:unique => false)}
-          specify {expect(subject).to be_an_enumerator}
-          specify {subject.each { |value| expect(value).to be_a_term }}
+          specify {subject.should be_an_enumerator}
+          specify {subject.each { |value| value.should be_a_value }}
         end
       end
 
-      context "#has_object?" do
-        specify do
-          checked = []
-          non_bnode_statements.each do |statement|
-            expect(@enumerable).to have_object(statement.object) unless checked.include?(statement.object)
-            checked << statement.object
-          end
-          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-          expect(@enumerable).not_to have_object(uri)
+      it "should implement #has_object?" do
+        checked = []
+        @statements.each do |statement|
+          @enumerable.has_object?(statement.object).should be_true unless checked.include?(statement.object)
+          checked << statement.object
         end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        @enumerable.has_object?(uri).should be_false
       end
 
-      its(:each_object) {should be_an_enumerator}
-      context "#each_object" do
-        specify {expect(subject.each_object.reject(&:node?).size).to eq objects.size}
-        specify {subject.each_object {|value| expect(value).to be_a_term}}
-        specify {subject.each_object {|value| expect(objects).to include(value) unless value.node?}}
+      it "should implement #each_object" do
+        objects = @statements.map { |s| s.object }.uniq
+        @enumerable.each_object.should be_an_enumerator
+        @enumerable.each_object.to_a.size.should == objects.size
+        @enumerable.each_object do |value|
+          value.should be_a_value
+          objects.should include(value)
+        end
       end
 
-      its(:enum_object) {should be_an_enumerator}
-      its(:enum_object) {should be_countable}
-      context "#enum_object" do
-        it "should enumerate all objects" do
-          expect(subject.enum_object.reject(&:node?)).to include(*objects)
-        end
+      it "should implement #enum_object" do
+        @enumerable.enum_object.should be_an_enumerator
+        @enumerable.enum_object.should be_countable
+        @enumerable.enum_object.to_a.should == @enumerable.each_object.to_a
       end
     end
 
     context "when enumerating contexts" do
-      it {should respond_to(:contexts)}
-      it {should respond_to(:has_context?)}
-      it {should respond_to(:each_context)}
-      it {should respond_to(:enum_context)}
+      it "should respond to #contexts" do
+        @enumerable.should respond_to(:contexts)
+      end
+
+      it "should respond to #has_context?" do
+        @enumerable.should respond_to(:has_context?)
+      end
+
+      it "should respond to #each_context" do
+        @enumerable.should respond_to(:each_context)
+      end
+
+      it "should respond to #enum_context" do
+        @enumerable.should respond_to(:enum_context)
+      end
 
-      its(:contexts) {should be_an_enumerator}
       describe "#contexts" do
         subject {@enumerable.contexts}
-        specify {expect(subject).to be_an_enumerator}
-        it "values should be resources" do
-          subject.each { |value| expect(value).to be_a_resource }
-        end
+        specify {subject.should be_an_enumerator}
+        specify {subject.each { |value| value.should be_a_resource }}
         context ":unique => false" do
           subject {@enumerable.contexts(:unique => false)}
-          specify {expect(subject).to be_an_enumerator}
-          it "values should be resources" do
-            subject.each { |value| expect(value).to be_a_resource }
-          end
+          specify {subject.should be_an_enumerator}
+          specify {subject.each { |value| value.should be_a_resource }}
         end
       end
 
       it "should implement #has_context?" do
-        if @supports_context
-          @statements.each do |statement|
-            if statement.has_context?
-              expect(@enumerable).to have_context(statement.context)
-            end
+        @statements.each do |statement|
+          if statement.has_context?
+            @enumerable.has_context?(statement.context).should be_true
           end
-          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-          expect(@enumerable).not_to have_context(uri)
         end
-      end
-
-      its(:each_context) {should be_an_enumerator}
-      context "#each_context" do
-        let(:contexts) {@statements.map { |s| s.context }.uniq.compact}
-        it "has appropriate number of contexts" do
-          if @supports_context
-            expect(subject.each_context.to_a.size).to eq contexts.size
-          end
-        end
-        it "values should be resources" do
-          subject.each_context {|value| expect(value).to be_a_resource}
-        end
-        it "should have all contexts" do
-          subject.each_context {|value| expect(contexts).to include(value)}
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        @enumerable.has_context?(uri).should be_false
+      end
+
+      it "should implement #each_context" do
+        contexts = @statements.map { |s| s.context }.uniq
+        contexts.delete nil
+        @enumerable.each_context.should be_an_enumerator
+        @enumerable.each_context.to_a.size.should == contexts.size
+        @enumerable.each_context do |value|
+          value.should be_a_resource
+          contexts.should include(value)
         end
       end
 
-      its(:enum_context) {should be_an_enumerator}
-      its(:enum_context) {should be_countable}
-      context "#enum_context" do
-        it "should enumerate all contexts" do
-          expect(subject.enum_context.to_a).to include(*@enumerable.each_context.to_a)
-        end
+      it "should implement #enum_context" do
+        @enumerable.enum_context.should be_an_enumerator
+        @enumerable.enum_context.should be_countable
+        @enumerable.enum_context.to_a.should == @enumerable.each_context.to_a
       end
     end
 
     context "when enumerating graphs" do
-      it {should respond_to(:each_graph)}
-      it {should respond_to(:enum_graph)}
+      it "should respond to #each_graph" do
+        @enumerable.should respond_to(:enum_graph)
+      end
+
+      it "should respond to #enum_graph" do
+        @enumerable.should respond_to(:enum_graph)
+      end
 
       describe "#each_graph" do
         subject {@enumerable.each_graph}
         it {should be_an_enumerator}
-        specify {subject.each { |value| expect(value).to be_a_graph }}
+        specify {subject.each { |value| value.should be_a_graph }}
       end
 
       describe "#enum_graph" do
         subject {@enumerable.enum_graph}
-        it {should be_an_enumerator}
-        it {should be_countable}
+        it {subject.should be_an_enumerator}
+        it {subject.should be_countable}
         it "enumerates the same as #each_graph" do
-          subject.to_a.should =~ @enumerable.each_graph.to_a # expect with match problematic
+          subject.to_a.should == @enumerable.each_graph.to_a
         end
       end
     end
 
     context "when converting" do
-      it {should respond_to(:to_hash)}
-      its(:to_hash) {should be_instance_of(Hash)}
-      context "#to_hash" do
-        it "should have as many keys as subjects" do
-          expect(subject.to_hash.keys.size).to eq @enumerable.subjects.to_a.size
-        end
+      it "should respond to #to_hash" do
+        @enumerable.should respond_to(:to_hash)
+      end
+
+      it "should implement #to_hash" do
+        @enumerable.to_hash.should be_instance_of(Hash)
+        @enumerable.to_hash.keys.size.should == @enumerable.subjects.to_a.size
       end
     end
   
     context "when dumping" do
-      it {should respond_to(:dump)}
+      it "should respond to #dump" do
+        @enumerable.should respond_to(:dump)
+      end
     
       it "should implement #dump" do
-        expect(subject.dump(:ntriples)).to eq RDF::NTriples::Writer.buffer() {|w| w << @enumerable}
+        @enumerable.dump(:ntriples).should == RDF::NTriples::Writer.buffer() {|w| w << @enumerable}
       end
     
       it "raises error on unknown format" do
-        expect {subject.dump(:foobar)}.to raise_error(RDF::WriterError, /No writer found/)
+        lambda {@enumerable.dump(:foobar)}.should raise_error(RDF::WriterError, /No writer found/)
       end
     end
   end