rdf-spec 1.1.0.p1 → 1.1.0.p2

data/lib/rdf/spec/format.rb

@@ -9,6 +9,7 @@ module RDF_Format
   end
 
   describe RDF::Format do
+    subject {@format_class}
     describe ".for" do
       RDF::Format.file_extensions.each do |ext, formats|
         it "detects #{formats.first} using file path foo.#{ext}" do
@@ -33,7 +34,7 @@ module RDF_Format
   
     describe ".reader" do
       it "returns a reader" do
-        @format_class.each do |f|
+        subject.each do |f|
           f.reader.should_not be_nil
         end
       end
@@ -43,7 +44,7 @@ module RDF_Format
       ##
       # May not return a writer, only does if one is defined by the format
       it "returns a writer" do
-        @format_class.each do |f|
+        subject.each do |f|
           format_namespace = f.name.split('::')[0..-2].inject(Kernel) {|base, const| base.const_get(const)}
           f.writer.should_not be_nil if format_namespace.const_defined?(:Writer)
         end

data/lib/rdf/spec/indexable.rb

@@ -9,24 +9,17 @@ module RDF_Indexable
   end
 
   describe RDF::Indexable do
-    it "responds to #indexed?" do
-      @indexable.respond_to?(:indexed?)
-    end
-  
-    it "implements #indexed?" do
-      !!@indexable.indexed?.should == @indexable.indexed?
-    end
-  
-    it "responds to #index!" do
-      @indexable.respond_to?(:index!)
-    end
+    subject {@indexable}
+    it {should respond_to(:indexed?)}
+    its(:indexed?) {should == subject.indexed?}
+    it {should respond_to(:index!)}
   
     it "does not raise error on #index! if #indexed?" do
-      lambda {@indexable.index!}.should_not raise_error if @indexable.indexed?
+      lambda {subject.index!}.should_not raise_error if subject.indexed?
     end
   
     it "raises error on #index! if not #indexed?" do
-      lambda {@indexable.index!}.should raise_error unless @indexable.indexed?
+      lambda {subject.index!}.should raise_error unless subject.indexed?
     end
   end
 end

data/lib/rdf/spec/mutable.rb

@@ -8,15 +8,14 @@ module RDF_Mutable
   before :each do
     raise '+@mutable+ must be defined in a before(:each) block' unless instance_variable_get('@mutable')
 
-    @filename = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
-
-    @subject = RDF::URI('http://rubygems.org/gems/rdf')
-    @context = RDF::URI('http://example.org/context')
-
     @supports_context = @mutable.respond_to?(:supports?) && @mutable.supports?(:context)
   end
+  let(:resource) {RDF::URI('http://rubygems.org/gems/rdf')}
+  let(:context) {RDF::URI('http://example.org/context')}
 
   describe RDF::Mutable do
+    subject {@mutable}
+
     context "readability" do
       require 'rdf/spec/readable'
 
@@ -37,119 +36,123 @@ module RDF_Mutable
       include RDF_Writable
     end
 
-    it "should be empty initially" do
-      @mutable.empty?.should be_true
-      @mutable.count.should be_zero
-    end
-
-    it "should be readable" do
-      @mutable.readable?.should be_true
-    end
-
-    it "should be writable" do
-      @mutable.writable?.should be_true
-    end
-
-    it "should be mutable" do
-      @mutable.immutable?.should be_false
-      @mutable.mutable?.should be_true
-    end
+    it {should be_empty}
+    it {should be_readable}
+    it {should be_writable}
+    it {should be_mutable}
+    it {should_not be_immutable}
+    it {should respond_to(:load)}
+    it {should respond_to(:clear)}
+    it {should respond_to(:delete)}
 
-    it "should support #load" do
-      @mutable.respond_to?(:load).should be_true
-    end
+    its(:count) {should be_zero}
 
     context "#load" do
       it "should require an argument" do
-        lambda { @mutable.load }.should raise_error(ArgumentError)
+        lambda { subject.load }.should raise_error(ArgumentError)
       end
 
       it "should accept a string filename argument" do
-        lambda { @mutable.load(@filename) }.should_not raise_error(ArgumentError)
+        pending("mutability", :unless => subject.mutable?) do
+          lambda { subject.load(RDF::Spec::TRIPLES_FILE) }.should_not raise_error(ArgumentError)
+        end
       end
 
       it "should accept an optional hash argument" do
-        lambda { @mutable.load(@filename,{}) }.should_not raise_error(ArgumentError)
+        pending("mutability", :unless => subject.mutable?) do
+          lambda { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.should_not raise_error(ArgumentError)
+        end
       end
 
       it "should load statements" do
-        @mutable.load @filename
-        @mutable.size.should ==  File.readlines(@filename).size
-        @mutable.should have_subject(@subject)
+        pending("mutability", :unless => subject.mutable?) do
+          subject.load RDF::Spec::TRIPLES_FILE
+          subject.size.should ==  File.readlines(RDF::Spec::TRIPLES_FILE).size
+          subject.should have_subject(resource)
+        end
       end
 
       it "should load statements with a context override" do
-        if @supports_context
-          @mutable.load @filename, :context => @context
-          @mutable.should have_context(@context)
-          @mutable.query(:context => @context).size.should == @mutable.size
+        pending("mutability and contextuality", :unless => (subject.mutable? && @supports_context)) do
+          subject.load RDF::Spec::TRIPLES_FILE, :context => context
+          subject.should have_context(context)
+          subject.query(:context => context).size.should == subject.size
         end
       end
     end
 
-    context "when deleting statements" do
-      before :each do
-        @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
-        @mutable.insert(*@statements)
+    context "#from_{reader}" do
+      it "should instantiate a reader" do
+        reader = mock("reader")
+        reader.should_receive(:new).and_return(RDF::NTriples::Reader.new(""))
+        RDF::Reader.should_receive(:for).with(:a_reader).and_return(reader)
+        subject.send(:from_a_reader)
       end
+    end
 
-      it "should support #delete" do
-        @mutable.should respond_to(:delete)
+    context "when deleting statements" do
+      before :each do
+        @statements = RDF::NTriples::Reader.new(File.open(RDF::Spec::TRIPLES_FILE)).to_a
+        subject.insert(*@statements)
       end
 
       it "should not raise errors" do
-        lambda { @mutable.delete(@statements.first) }.should_not raise_error
+        pending("mutability", :unless => subject.mutable?) do
+          lambda { subject.delete(@statements.first) }.should_not raise_error
+        end
       end
 
       it "should support deleting one statement at a time" do
-        @mutable.delete(@statements.first)
-        @mutable.should_not have_statement(@statements.first)
+        pending("mutability", :unless => subject.mutable?) do
+          subject.delete(@statements.first)
+          subject.should_not have_statement(@statements.first)
+        end
       end
 
       it "should support deleting multiple statements at a time" do
-        @mutable.delete(*@statements)
-        @statements.find { |s| @mutable.has_statement?(s) }.should be_false
+        pending("mutability", :unless => subject.mutable?) do
+          subject.delete(*@statements)
+          subject.find { |s| subject.has_statement?(s) }.should be_false
+        end
       end
 
       it "should support wildcard deletions" do
-        # nothing deleted
-        require 'digest/sha1'
-        count = @mutable.count
-        @mutable.delete([nil, nil, random = Digest::SHA1.hexdigest(File.read(__FILE__))])
-        @mutable.should_not be_empty
-        @mutable.count.should == count
-
-        # everything deleted
-        @mutable.delete([nil, nil, nil])
-        @mutable.should be_empty
+        pending("mutability", :unless => subject.mutable?) do
+          # nothing deleted
+          require 'digest/sha1'
+          count = subject.count
+          subject.delete([nil, nil, random = Digest::SHA1.hexdigest(File.read(__FILE__))])
+          subject.should_not be_empty
+          subject.count.should == count
+
+          # everything deleted
+          subject.delete([nil, nil, nil])
+          subject.should be_empty
+        end
       end
 
       it "should only delete statements when the context matches" do
-        # Setup three statements identical except for context
-        count = @mutable.count + (@supports_context ? 3 : 1)
-        s1 = RDF::Statement.new(@subject, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
-        s2 = s1.dup
-        s2.context = RDF::URI.new("urn:context:1")
-        s3 = s1.dup
-        s3.context = RDF::URI.new("urn:context:2")
-        @mutable.insert(s1)
-        @mutable.insert(s2)
-        @mutable.insert(s3)
-        @mutable.count.should == count
-
-        # Delete one by one
-        @mutable.delete(s1)
-        @mutable.count.should == count - (@supports_context ? 1 : 1)
-        @mutable.delete(s2)
-        @mutable.count.should == count - (@supports_context ? 2 : 1)
-        @mutable.delete(s3)
-        @mutable.count.should == count - (@supports_context ? 3 : 1)
-      end
-    end
-
-    context "when clearing all statements" do
-      it "should support #clear" do
-        @mutable.should respond_to(:clear)
+        pending("mutability", :unless => subject.mutable?) do
+          # Setup three statements identical except for context
+          count = subject.count + (@supports_context ? 3 : 1)
+          s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
+          s2 = s1.dup
+          s2.context = RDF::URI.new("urn:context:1")
+          s3 = s1.dup
+          s3.context = RDF::URI.new("urn:context:2")
+          subject.insert(s1)
+          subject.insert(s2)
+          subject.insert(s3)
+          subject.count.should == count
+
+          # Delete one by one
+          subject.delete(s1)
+          subject.count.should == count - (@supports_context ? 1 : 1)
+          subject.delete(s2)
+          subject.count.should == count - (@supports_context ? 2 : 1)
+          subject.delete(s3)
+          subject.count.should == count - (@supports_context ? 3 : 1)
+        end
       end
     end
   end

data/lib/rdf/spec/queryable.rb

@@ -7,69 +7,67 @@ module RDF_Queryable
   before :each do
     raise '+@queryable+ must be defined in a before(:each) block' unless instance_variable_get('@queryable')
 
-    @doap = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nq'))
-    @doaps = RDF::NQuads::Reader.new(File.open(@doap)).to_a
-    @statements = @doaps
+    @doap = RDF::Spec::QUADS_FILE
+    @statements = RDF::Spec.quads
 
     if @queryable.empty?
-      if @queryable.respond_to?(:<<)
-        @doaps.each { |statement| @queryable << statement }
+      if @queryable.respond_to?(:<<) && (@queryable.writable? rescue true)
+        @statements.each { |statement| @queryable << statement }
       else
         raise "@queryable must respond to #<< or be pre-populated with the statements in #{@doap} in a before(:each) block"
       end
     end
-
-    @subject = RDF::URI('http://rubygems.org/gems/rdf')
   end
+  let(:resource) {RDF::URI('http://rubygems.org/gems/rdf')}
+  let(:literal) {RDF::Literal.new('J. Random Hacker')}
 
   describe RDF::Queryable do
+    subject {@queryable}
     ##
     # @see RDF::Queryable#query
     describe "#query" do
-      it "should respond to #query" do
-        @queryable.should respond_to(:query)
-      end
+      it {should respond_to(:query)}
 
       context "when called" do
         it "requires an argument" do
-          lambda { @queryable.query }.should raise_error(ArgumentError)
+          lambda { subject.query }.should raise_error(ArgumentError)
         end
 
         it "accepts a pattern argument" do
-          lambda { @queryable.query(RDF::Query::Pattern.new(nil, nil, nil)) }.should_not raise_error(ArgumentError)
-          lambda { @queryable.query(RDF::Query::Pattern.new(:s, :p, :o)) }.should_not raise_error(ArgumentError)
+          lambda { subject.query(RDF::Query::Pattern.new(nil, nil, nil)) }.should_not raise_error(ArgumentError)
+          lambda { subject.query(RDF::Query::Pattern.new(:s, :p, :o)) }.should_not raise_error(ArgumentError)
         end
 
         it "accepts a statement argument" do
-          lambda { @queryable.query(RDF::Statement.new(nil, nil, nil)) }.should_not raise_error(ArgumentError)
+          lambda { subject.query(RDF::Statement.new(nil, nil, nil)) }.should_not raise_error(ArgumentError)
         end
 
         it "accepts a triple argument" do
-          lambda { @queryable.query([nil, nil, nil]) }.should_not raise_error(ArgumentError)
+          lambda { subject.query([nil, nil, nil]) }.should_not raise_error(ArgumentError)
         end
 
         it "accepts a quad argument" do
-          lambda { @queryable.query([nil, nil, nil, nil]) }.should_not raise_error(ArgumentError)
+          lambda { subject.query([nil, nil, nil, nil]) }.should_not raise_error(ArgumentError)
         end
 
         it "accepts a hash argument" do
-          lambda { @queryable.query({}) }.should_not raise_error(ArgumentError)
+          lambda { subject.query({}) }.should_not raise_error(ArgumentError)
         end
 
         it "does not alter a given hash argument" do
-          query = {:subject => @subject, :predicate => RDF::DOAP.name, :object => RDF::FOAF.Person}
+          query = {:subject => resource, :predicate => RDF::DOAP.name, :object => RDF::FOAF.Person}
           original_query = query.dup
-          @queryable.query(query)
+          subject.query(query)
           query.should == original_query
         end
 
         it "rejects other kinds of arguments" do
-          lambda { @queryable.query(nil) }.should raise_error(ArgumentError)
+          lambda { subject.query(nil) }.should raise_error(ArgumentError)
         end
 
         context "with a block" do
           it "yields statements" do
-            @queryable.query([nil, nil, nil]) do |statement|
+            subject.query([nil, nil, nil]) do |statement|
               statement.should be_a_statement
             end
           end
@@ -77,48 +75,48 @@ module RDF_Queryable
 
         context "without a block" do
           it "returns an enumerator" do
-            @queryable.query([nil, nil, nil]).should be_an_enumerator
+            subject.query([nil, nil, nil]).should be_an_enumerator
           end
 
           it "returns an enumerable enumerator" do
-            @queryable.query([nil, nil, nil]).should be_enumerable
+            subject.query([nil, nil, nil]).should be_enumerable
           end
 
           it "returns a queryable enumerator" do
-            @queryable.query([nil, nil, nil]).should be_queryable
+            subject.query([nil, nil, nil]).should be_queryable
           end
 
           it "returns statements" do
-            @queryable.query([nil, nil, nil]).each do |statement|
+            subject.query([nil, nil, nil]).each do |statement|
               statement.should be_a_statement
             end
           end
 
           it "returns the correct number of results for array queries" do
-            @queryable.query([nil, nil, nil]).size.should == @statements.size
-            @queryable.query([@subject, nil, nil]).size.should == File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
-            @queryable.query([RDF::URI("http://ar.to/#self"), nil, nil]).size.should == File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
-            @queryable.query([@subject, RDF::DOAP.name, nil]).size.should == 1
-            @queryable.query([nil, nil, RDF::DOAP.Project]).size.should == 1
+            subject.query([nil, nil, nil]).size.should == @statements.size
+            subject.query([resource, nil, nil]).size.should == File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
+            subject.query([RDF::URI("http://ar.to/#self"), nil, nil]).size.should == File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
+            subject.query([resource, RDF::DOAP.name, nil]).size.should == 1
+            subject.query([nil, nil, RDF::DOAP.Project]).size.should == 1
           end
 
           it "returns the correct number of results for hash queries" do
-            @queryable.query({}).size.should == @statements.size
-            @queryable.query(:subject => @subject) .size.should == File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
-            @queryable.query(:subject => @subject, :predicate => RDF::DOAP.name).size.should == 1
-            @queryable.query(:object => RDF::DOAP.Project).size.should == 1
+            subject.query({}).size.should == @statements.size
+            subject.query(:subject => resource) .size.should == File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
+            subject.query(:subject => resource, :predicate => RDF::DOAP.name).size.should == 1
+            subject.query(:object => RDF::DOAP.Project).size.should == 1
           end
         end
 
         context "with specific patterns from SPARQL" do
           context "triple pattern combinations" do
             it "?s p o" do
-              @queryable.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal.new(1)).to_a.should ==
+              subject.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal.new(1)).to_a.should ==
                 [RDF::Statement.new(RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1), RDF::Statement.new(RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1)]
             end
 
             it "s ?p o" do
-              @queryable.query(:subject => RDF::URI("http://example.org/xi2"), :object => RDF::Literal.new(1)).to_a.should ==
+              subject.query(:subject => RDF::URI("http://example.org/xi2"), :object => RDF::Literal.new(1)).to_a.should ==
                 [RDF::Statement.new(RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1)]
             end
           end
@@ -126,35 +124,24 @@ module RDF_Queryable
           # From data-r2/expr-equals
           context "data/r2/expr-equals" do
             context "graph-1" do
-              before(:each) do
-                @solutions = @queryable.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal::Integer.new(1)).to_a
-              end
+              subject {@queryable.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal::Integer.new(1)).to_a}
+              its(:count) {should == 2}
 
               it "has two solutions" do
-                @solutions.count.should == 2
-              end
-
-              it "has xi1 as a solution" do
-                @solutions.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}.should be_true
+                subject.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}.should be_true
               end
 
               it "has xi2 as a solution" do
-                @solutions.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}.should be_true
+                subject.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}.should be_true
               end
             end
 
-
             context "graph-2" do
-              before(:each) do
-                @solutions = @queryable.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal::Double.new("1.0e0")).to_a
-              end
-
-              it "has one solution" do
-                @solutions.count.should == 1
-              end
+              subject {@queryable.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal::Double.new("1.0e0")).to_a}
+              its(:count) {should == 1}
 
               it "has xd1 as a solution" do
-                @solutions.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}.should be_true
+                subject.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}.should be_true
               end
             end
           end
@@ -166,17 +153,17 @@ module RDF_Queryable
     # @see RDF::Queryable#query_pattern
     describe "#query_pattern" do
       it "defines a protected #query_pattern method" do
-        @queryable.class.protected_method_defined?(:query_pattern).should be_true
+        subject.class.protected_method_defined?(:query_pattern).should be_true
       end
 
       context "when called" do
         it "requires an argument" do
-          lambda { @queryable.send(:query_pattern) }.should raise_error(ArgumentError)
+          lambda { subject.send(:query_pattern) }.should raise_error(ArgumentError)
         end
 
         it "yields to the given block" do
           called = false
-          @queryable.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
+          subject.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
             called = true
             break
           end
@@ -184,7 +171,7 @@ module RDF_Queryable
         end
 
         it "yields statements" do
-          @queryable.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
+          subject.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
             statement.should be_a_statement
           end
         end
@@ -202,7 +189,7 @@ module RDF_Queryable
             pattern = RDF::Query::Pattern.from(pattern)
             it "returns #{result.inspect} given #{pattern.inspect}" do
               solutions = []
-              @queryable.send(:query_pattern, pattern) {|s| solutions << s}
+              subject.send(:query_pattern, pattern) {|s| solutions << s}
               solutions.should == result
             end
           end
@@ -212,33 +199,33 @@ module RDF_Queryable
           it "returns statements from all contexts with no context" do
             pattern = RDF::Query::Pattern.new(nil, nil, nil, :context => nil)
             solutions = []
-            @queryable.send(:query_pattern, pattern) {|s| solutions << s}
+            subject.send(:query_pattern, pattern) {|s| solutions << s}
             solutions.size.should == @statements.size
           end
 
           it "returns statements from unnamed contexts with false context" do
             pattern = RDF::Query::Pattern.new(nil, nil, nil, :context => false)
             solutions = []
-            @queryable.send(:query_pattern, pattern) {|s| solutions << s}
-            context_statements = @queryable.statements.reject {|st| st.has_context?}.length
+            subject.send(:query_pattern, pattern) {|s| solutions << s}
+            context_statements = subject.statements.reject {|st| st.has_context?}.length
             solutions.size.should == context_statements
           end
 
           it "returns statements from named contexts with variable context" do
-            unless @queryable.contexts.to_a.empty?
+            unless subject.contexts.to_a.empty?
               pattern = RDF::Query::Pattern.new(nil, nil, nil, :context => :c)
               solutions = []
-              @queryable.send(:query_pattern, pattern) {|s| solutions << s}
-              context_statements = @queryable.statements.select {|st| st.has_context?}.length
+              subject.send(:query_pattern, pattern) {|s| solutions << s}
+              context_statements = subject.statements.select {|st| st.has_context?}.length
               solutions.size.should == context_statements
             end
           end
 
           it "returns statements from specific context with URI context" do
-            unless @queryable.contexts.to_a.empty?
+            unless subject.contexts.to_a.empty?
               pattern = RDF::Query::Pattern.new(nil, nil, nil, :context => RDF::URI("http://ar.to/#self"))
               solutions = []
-              @queryable.send(:query_pattern, pattern) {|s| solutions << s}
+              subject.send(:query_pattern, pattern) {|s| solutions << s}
               solutions.size.should == File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
             end
           end
@@ -249,68 +236,64 @@ module RDF_Queryable
     ##
     # @see RDF::Queryable#first
     describe "#first" do
-      before :all do
-        @failing_pattern = [RDF::Node.new] * 3
-      end
+      let(:failing_pattern) {[RDF::Node.new] * 3}
 
       it "should respond to #first" do
-        @queryable.should respond_to(:first)
+        subject.should respond_to(:first)
       end
 
       it "returns enumerator without a pattern" do
-        lambda { @queryable.first }.should_not raise_error(ArgumentError)
-        @queryable.first.should == @queryable.each.first # uses an Enumerator
+        lambda { subject.first }.should_not raise_error(ArgumentError)
+        subject.first.should == subject.each.first # uses an Enumerator
       end
 
       it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        matching_patterns = [[nil, nil, nil], @queryable.each.first]
+        matching_patterns = [[nil, nil, nil], subject.each.first]
         matching_patterns.each do |matching_pattern|
-          @queryable.first(matching_pattern).should == @queryable.query(matching_pattern).each.first
+          subject.first(matching_pattern).should == subject.query(matching_pattern).each.first
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        @queryable.first(@failing_pattern).should be_nil
+        subject.first(failing_pattern).should be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
         queryable.first.should be_nil
-        queryable.first(@failing_pattern).should be_nil
+        queryable.first(failing_pattern).should be_nil
       end
     end
 
     ##
     # @see RDF::Queryable#first_subject
     describe "#first_subject" do
-      before :all do
-        @failing_pattern = [RDF::Node.new, nil, nil]
-      end
+      let(:failing_pattern) {[RDF::Node.new, nil, nil]}
 
       it "should respond to #first_subject" do
-        @queryable.should respond_to(:first_subject)
+        subject.should respond_to(:first_subject)
       end
 
       it "returns enumerator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        lambda { @queryable.first_subject }.should_not raise_error(ArgumentError)
-        @queryable.first_subject.should == @queryable.first.subject
+        lambda { subject.first_subject }.should_not raise_error(ArgumentError)
+        subject.first_subject.should == subject.first.subject
       end
 
       it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        matching_patterns = [[nil, nil, nil], [@queryable.first.subject, nil, nil]]
+        matching_patterns = [[nil, nil, nil], [subject.first.subject, nil, nil]]
         matching_patterns.each do |matching_pattern|
-          @queryable.first_subject(matching_pattern).should == @queryable.query(matching_pattern).first.subject
+          subject.first_subject(matching_pattern).should == subject.query(matching_pattern).first.subject
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        @queryable.first_subject(@failing_pattern).should be_nil
+        subject.first_subject(failing_pattern).should be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
         queryable.first_subject.should be_nil
-        queryable.first_subject(@failing_pattern).should be_nil
+        queryable.first_subject(failing_pattern).should be_nil
       end
     end
 
@@ -318,34 +301,30 @@ module RDF_Queryable
     # @see RDF::Queryable#first_predicate
 
     describe "#first_predicate" do
-      before :all do
-        @failing_pattern = [nil, RDF::Node.new, nil]
-      end
+      let(:failing_pattern) {[nil, RDF::Node.new, nil]}
 
-      it "should respond to #first_predicate" do
-        @queryable.should respond_to(:first_predicate)
-      end
+      it {should respond_to(:first_predicate)}
 
       it "returns enumerator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        lambda { @queryable.first_predicate }.should_not raise_error(ArgumentError)
-        @queryable.first_predicate.should == @queryable.first.predicate
+        lambda { subject.first_predicate }.should_not raise_error(ArgumentError)
+        subject.first_predicate.should == subject.first.predicate
       end
 
       it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        matching_patterns = [[nil, nil, nil], [nil, @queryable.first.predicate, nil]]
+        matching_patterns = [[nil, nil, nil], [nil, subject.first.predicate, nil]]
         matching_patterns.each do |matching_pattern|
-          @queryable.first_predicate(matching_pattern).should == @queryable.query(matching_pattern).first.predicate
+          subject.first_predicate(matching_pattern).should == subject.query(matching_pattern).first.predicate
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        @queryable.first_predicate(@failing_pattern).should be_nil
+        subject.first_predicate(failing_pattern).should be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
         queryable.first_predicate.should be_nil
-        queryable.first_predicate(@failing_pattern).should be_nil
+        queryable.first_predicate(failing_pattern).should be_nil
       end
     end
 
@@ -353,76 +332,67 @@ module RDF_Queryable
     # @see RDF::Queryable#first_object
 
     describe "#first_object" do
-      before :all do
-        @failing_pattern = [nil, nil, RDF::Node.new]
-      end
-
-      it "should respond to #first_object" do
-        @queryable.should respond_to(:first_object)
-      end
+      let(:failing_pattern) {[nil, nil, RDF::Node.new]}
+      it {should respond_to(:first_object)}
 
       it "returns enurator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        lambda { @queryable.first_object }.should_not raise_error(ArgumentError)
-        @queryable.first_object.should == @queryable.first.object
+        lambda { subject.first_object }.should_not raise_error(ArgumentError)
+        subject.first_object.should == subject.first.object
       end
 
       it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        matching_patterns = [[nil, nil, nil], [nil, nil, @queryable.first.object]]
+        matching_patterns = [[nil, nil, nil], [nil, nil, subject.first.object]]
         matching_patterns.each do |matching_pattern|
-          @queryable.first_object(matching_pattern).should == @queryable.query(matching_pattern).first.object
+          subject.first_object(matching_pattern).should == subject.query(matching_pattern).first.object
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        @queryable.first_object(@failing_pattern).should be_nil
+        subject.first_object(failing_pattern).should be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
         queryable.first_object.should be_nil
-        queryable.first_object(@failing_pattern).should be_nil
+        queryable.first_object(failing_pattern).should be_nil
       end
     end
 
     ##
     # @see RDF::Queryable#first_literal
 
-    it "returns to #first_literal" do
-      @queryable.should respond_to(:first_literal)
-    end
-
     describe "#first_literal" do
-      before :each do
-        # FIXME: these tests should be using the provided @queryable, if possible.
-        @queryable = RDF::Graph.new do |graph|
-          @subject = RDF::Node.new
-          graph << [@subject, RDF.type, RDF::DOAP.Project]
-          graph << [@subject, RDF::DC.creator, RDF::URI.new('http://example.org/#jhacker')]
-          graph << [@subject, RDF::DC.creator, @literal = RDF::Literal.new('J. Random Hacker')]
+      let(:failing_pattern) {[nil, nil, RDF::Node.new]}
+      let(:resource) {RDF::Node.new}
+      subject {
+        RDF::Graph.new do |graph|
+          graph << [resource, RDF.type, RDF::DOAP.Project]
+          graph << [resource, RDF::DC.creator, RDF::URI.new('http://example.org/#jhacker')]
+          graph << [resource, RDF::DC.creator, literal]
         end
-        @failing_pattern = [nil, nil, RDF::Node.new]
-      end
+      }
+      it {should respond_to(:first_literal)}
 
       it "returns a literal without a pattern" do
-        lambda { @queryable.first_literal }.should_not raise_error(ArgumentError)
-        @queryable.first_literal.should == @literal
+        lambda { subject.first_literal }.should_not raise_error(ArgumentError)
+        subject.first_literal.should == literal
       end
 
       it "returns the correct value when the pattern matches" do
-        matching_patterns = [[nil, nil, nil], [@subject, nil, nil], [nil, RDF::DC.creator, nil], [nil, nil, @literal]]
+        matching_patterns = [[nil, nil, nil], [resource, nil, nil], [nil, RDF::DC.creator, nil], [nil, nil, literal]]
         matching_patterns.each do |matching_pattern|
-          @queryable.first_literal(matching_pattern).should == @literal
+          subject.first_literal(matching_pattern).should == literal
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        @queryable.first_literal(@failing_pattern).should be_nil
+        subject.first_literal(failing_pattern).should be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
         queryable.first_literal.should be_nil
-        queryable.first_literal(@failing_pattern).should be_nil
+        queryable.first_literal(failing_pattern).should be_nil
       end
     end
 
@@ -430,40 +400,35 @@ module RDF_Queryable
     # @see RDF::Queryable#first_value
 
     describe "#first_value" do
-      before :all do
-        @failing_pattern = [nil, nil, RDF::Node.new]
-      end
-
-      it "should respond to #first_value" do
-        @queryable.should respond_to(:first_value)
-      end
+      let(:failing_pattern) {[nil, nil, RDF::Node.new]}
+      it {should respond_to(:first_value)}
 
       it "returns first literal without a pattern" do
-        lambda { @queryable.first_value }.should_not raise_error(ArgumentError)
-        @queryable.first_value.should == @queryable.first_literal.value
+        lambda { subject.first_value }.should_not raise_error(ArgumentError)
+        subject.first_value.should == subject.first_literal.value
       end
 
       it "returns the correct value when the pattern matches" do
         matching_patterns = []
-        @queryable.each do |statement|
+        subject.each do |statement|
           if statement.object.is_a?(RDF::Literal)
             matching_pattern = [statement.subject, statement.predicate, nil]
             unless matching_patterns.include?(matching_pattern)
               matching_patterns << matching_pattern
-              @queryable.first_value(matching_pattern).should == @queryable.first_literal(matching_pattern).value
+              subject.first_value(matching_pattern).should == subject.first_literal(matching_pattern).value
             end
           end
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        @queryable.first_value(@failing_pattern).should be_nil
+        subject.first_value(failing_pattern).should be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
         queryable.first_value.should be_nil
-        queryable.first_value(@failing_pattern).should be_nil
+        queryable.first_value(failing_pattern).should be_nil
       end
     end
   end