rdf-spec 1.0.0 → 1.0.5

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.5

data/lib/rdf/spec/enumerable.rb

@@ -22,453 +22,429 @@ module RDF_Enumerable
   end
 
   describe RDF::Enumerable do
-    describe "#supports?" do
-      it "responds to #supports?" do
-        @enumerable.respond_to?(:support?)
+    subject {@enumerable}
+    it {should respond_to(:supports?)}
+    it {should respond_to(:count)}
+    it {should respond_to(:size)}
+
+    it {should respond_to(:statements)}
+    it {should respond_to(:has_statement?)}
+    it {should respond_to(:each_statement)}
+    it {should respond_to(:enum_statement)}
+
+    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(:quads)}
+    it {should respond_to(:has_quad?)}
+    it {should respond_to(:each_quad)}
+    it {should respond_to(:enum_quad)}
+
+    it {should respond_to(:subjects)}
+    it {should respond_to(:has_subject?)}
+    it {should respond_to(:each_subject)}
+    it {should respond_to(:enum_subject)}
+
+    it {should respond_to(:predicates)}
+    it {should respond_to(:has_predicate?)}
+    it {should respond_to(:each_predicate)}
+    it {should respond_to(:enum_predicate)}
+
+    it {should respond_to(:objects)}
+    it {should respond_to(:has_object?)}
+    it {should respond_to(:each_object)}
+    it {should respond_to(:enum_object)}
+
+    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(:each_graph)}
+    it {should respond_to(:enum_graph)}
+
+    it {should respond_to(:to_hash)}
+    it {should respond_to(:dump)}
+
+    it {should be_valid}
+    it {should_not be_empty}
+    its(:size) {should == @statements.size}
+    its(:count) {should == @statements.size}
+
+    it "returns is_invalid if any statement is invalid" do
+      if subject.respond_to?(:<<)
+        s = RDF::Statement.from([nil, nil, nil])
+        s.should_not be_valid
+        subject << s
+        subject.should_not be_valid
       end
     end
 
-    describe "valid?" do
-      it "returns true if all statements are valid" do
-        @enumerable.should be_valid
-      end
-      
-      it "returns false if any statement is invalid" do
-        if @enumerable.respond_to?(:<<)
-          s = RDF::Statement.from([nil, nil, nil])
-          s.should_not be_valid
-          @enumerable << s
-          @enumerable.should_not be_valid
-        else
-          pending("can't add statement to immutable enumerable")
-        end
-      end
+    context "when extending an empty array" do
+      subject {[].extend(RDF::Enumerable)}
+      it {should be_empty}
+      its(:size) {should == 0}
+      its(:count) {should == 0}
     end
 
-    context "when counting statements" do
-      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
+    describe "#statements" do
+      subject {@enumerable.statements}
+      it {should be_an_enumerator}
+      its(:size) {should == @statements.size}
+      it "should iterrate statements" do
+        subject.statements.each { |statement| statement.should be_a_statement }
       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" do
-        @enumerable.should respond_to(:statements)
-      end
-
-      it "should respond to #has_statement?" do
-        @enumerable.should respond_to(:has_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
+      it "should have all statements" do
         @statements.each do |statement|
-          @enumerable.has_statement?(statement).should be_true
+          subject.should have_statement(statement)
         end
+      end
 
+      it "should not have statements in a different context" do
         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
+            subject.should_not have_statement(s)
           end
         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 implement #each_statement" do
-        @enumerable.each_statement.should be_an_enumerator
-        @enumerable.each_statement { |statement| statement.should be_a_statement }
-      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
+      it "should not have an unknown statement" do
+        unknown_statement = RDF::Statement.new(RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new)
+        subject.has_statement?(unknown_statement).should be_false
       end
     end
 
-    context "when enumerating triples" do
-      it "should respond to #triples" do
-        @enumerable.should respond_to(:triples)
-      end
-
-      it "should respond to #has_triple?" do
-        @enumerable.should respond_to(:has_triple?)
-      end
-
-      it "should respond to #each_triple" do
-        @enumerable.should respond_to(:each_triple)
-      end
-
-      it "should respond to #enum_triple" do
-        @enumerable.should respond_to(:enum_triple)
-      end
-
-      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
+    describe "#has_statement?" do
+      it "has all statements" do
         @statements.each do |statement|
-          @enumerable.has_triple?(statement.to_triple).should be_true
+          subject.should have_statement(statement)
         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" do
-        @enumerable.should respond_to(:quads)
-      end
-
-      it "should respond to #has_quad?" do
-        @enumerable.should respond_to(:has_quad?)
+    describe "#each_statement" do
+      subject {@enumerable.each_statement}
+      it {should be_an_enumerator}
+      it "should all be statements" do
+        subject { |statement| statement.should be_a_statement }
       end
+    end
 
-      it "should respond to #each_quad" do
-        @enumerable.should respond_to(:each_quad)
+    describe "#enum_statement" do
+      subject {@enumerable.enum_statement}
+      it {should be_an_enumerator}
+      it {should be_countable}
+      it {should be_enumerable}
+      it {should be_queryable}
+      it "should all be statements" do
+        subject { |statement| statement.should be_a_statement }
       end
-
-      it "should respond to #enum_quad" do
-        @enumerable.should respond_to(:enum_quad)
+      it "should have all statements" do
+        subject.to_a.should =~ @statements.to_a
       end
+    end
 
-      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 }
+    describe "#triples" do
+      subject {@enumerable.triples}
+      it {should be_an_enumerator}
+      it {subject.to_a.size.should == @statements.size}
+      it "should all be triples" do
+        subject.each {|triple| triple.should be_a_triple}
       end
+    end
 
-      it "should implement #has_quad?" do
+    describe "#has_triple?" do
+      it "has all triples" do
         @statements.each do |statement|
-          @enumerable.has_quad?(statement.to_quad).should be_true
+          subject.should have_triple(statement.to_triple)
         end
       end
+    end
 
-      it "should implement #each_quad" do
-        @enumerable.each_quad.should be_an_enumerator
-        @enumerable.each_quad { |*quad| quad.should be_a_quad }
+    describe "#each_triple" do
+      subject {@enumerable.each_triple}
+      it {should be_an_enumerator}
+      it "has all triples" do
+        subject do |*triple|
+          triple.should be_a_triple
+        end
       end
+    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
+    describe "#enum_triple" do
+      subject {@enumerable.enum_triple}
+      it {should be_an_enumerator}
+      it {should be_countable}
+      it "should have all triples" do
+        subject.to_a.should =~ @enumerable.each_triple.to_a
       end
     end
 
-    context "when enumerating subjects" do
-      it "should respond to #subjects" do
-        @enumerable.should respond_to(:subjects)
+    describe "#quads" do
+      subject {@enumerable.quads}
+      it {should be_an_enumerator}
+      it {subject.to_a.size.should == @statements.size}
+      it "should all be quads" do
+        subject.each {|quad| quad.should be_a_quad}
       end
+    end
 
-      it "should respond to #has_subject?" do
-        @enumerable.should respond_to(:has_subject?)
+    describe "#has_quad?" do
+      it "has all quads" do
+        @statements.each do |statement|
+          subject.should have_quad(statement.to_quad)
+        end
       end
+    end
 
-      it "should respond to #each_subject" do
-        @enumerable.should respond_to(:each_subject)
+    describe "#each_quad" do
+      subject {@enumerable.each_quad}
+      it {should be_an_enumerator}
+      it "has all quads" do
+        subject do |*quad|
+          quad.should be_a_quad
+        end
       end
+    end
 
-      it "should respond to #enum_subject" do
-        @enumerable.should respond_to(:enum_subject)
+    describe "#enum_quad" do
+      subject {@enumerable.enum_quad}
+      it {should be_an_enumerator}
+      it {should be_countable}
+      it "should have all triples" do
+        subject.to_a.should =~ @enumerable.each_quad.to_a
       end
+    end
 
-      describe "#subjects" do
-        subject {@enumerable.subjects}
+    describe "#subjects" do
+      subject {@enumerable.subjects}
+      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 {subject.should be_an_enumerator}
         specify {subject.each { |value| value.should be_a_resource }}
-        context ":unique => false" do
-          subject {@enumerable.subjects(:unique => false)}
-          specify {subject.should be_an_enumerator}
-          specify {subject.each { |value| value.should be_a_resource }}
-        end
       end
+    end
 
-      it "should implement #has_subject?" do
+    describe "#has_subject?" do
+      it "has all subjects" do
         checked = []
         @statements.each do |statement|
-          @enumerable.has_subject?(statement.subject).should be_true unless checked.include?(statement.subject)
+          subject.should 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')
-        @enumerable.has_predicate?(uri).should be_false
+        subject.should_not have_subject(uri)
       end
+    end
 
-      it "should implement #each_subject" do
-        @enumerable.each_subject.should be_an_enumerator
+    describe "#each_subject" do
+      subject {@enumerable.each_subject}
+      it {should be_an_enumerator}
+      it "has all subjects" do
         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)
+        subject.to_a.size.should == subjects.size
+        subject do |term|
+          term.should be_a_term
+          subjects.should include(term)
         end
       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
-      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)
+    describe "#enum_subject" do
+      subject {@enumerable.enum_subject}
+      it {should be_an_enumerator}
+      it {should be_countable}
+      it "should have all subjects" do
+        subject.to_a.should =~ @enumerable.each_subject.to_a
       end
+    end
 
-      describe "#predicates" do
-        subject {@enumerable.predicates}
+    describe "#predicates" do
+      subject {@enumerable.predicates}
+      specify {subject.should be_an_enumerator}
+      specify {subject.each { |value| value.should be_a_resource }}
+      context ":unique => false" do
+        subject {@enumerable.predicates(:unique => false)}
         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 {subject.should be_an_enumerator}
-          specify {subject.each { |value| value.should be_a_resource }}
-        end
+        specify {subject.each { |value| value.should be_a_resource }}
       end
+    end
 
-      it "should implement #has_predicate?" do
+    describe "#has_predicate?" do
+      it "has all predicates" do
         checked = []
         @statements.each do |statement|
-          @enumerable.has_predicate?(statement.predicate).should be_true unless checked.include?(statement.object)
+          subject.should 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')
-        @enumerable.has_predicate?(uri).should be_false
+        subject.should_not have_predicate(uri)
       end
+    end
 
-      it "should implement #each_predicate" do
+    describe "#each_predicate" do
+      subject {@enumerable.each_predicate}
+      it {should be_an_enumerator}
+      it "has all predicates" 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)
+        subject.to_a.size.should == predicates.size
+        subject do |term|
+          term.should be_a_term
+          predicates.should include(term)
         end
       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
-      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)
+    describe "#enum_predicate" do
+      subject {@enumerable.enum_predicate}
+      it {should be_an_enumerator}
+      it {should be_countable}
+      it "should have all predicates" do
+        subject.to_a.should =~ @enumerable.each_predicate.to_a
       end
+    end
 
-      describe "#objects" do
-        subject {@enumerable.objects}
+    describe "#objects" do
+      subject {@enumerable.objects}
+      specify {subject.should be_an_enumerator}
+      specify {subject.each { |value| value.should be_a_term }}
+      context ":unique => false" do
+        subject {@enumerable.objects(:unique => false)}
         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 {subject.should be_an_enumerator}
-          specify {subject.each { |value| value.should be_a_value }}
-        end
+        specify {subject.each { |value| value.should be_a_term }}
       end
+    end
 
-      it "should implement #has_object?" do
+    describe "#has_object?" do
+      it "has all objects" do
         checked = []
         @statements.each do |statement|
-          @enumerable.has_object?(statement.object).should be_true unless checked.include?(statement.object)
+          subject.should 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')
-        @enumerable.has_object?(uri).should be_false
+        subject.should_not have_object(uri)
       end
+    end
 
-      it "should implement #each_object" do
+    describe "#each_object" do
+      subject {@enumerable.each_object}
+      it {should be_an_enumerator}
+      it "has all objects" 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)
+        subject.to_a.size.should == objects.size
+        subject do |term|
+          term.should be_a_term
+          objects.should include(term)
         end
       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" 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)
+    describe "#enum_object" do
+      subject {@enumerable.enum_object}
+      it {should be_an_enumerator}
+      it {should be_countable}
+      it "should have all objects" do
+        subject.to_a.should =~ @enumerable.each_object.to_a
       end
+    end
 
-      describe "#contexts" do
-        subject {@enumerable.contexts}
+    describe "#contexts" do
+      subject {@enumerable.contexts}
+      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 {subject.should be_an_enumerator}
         specify {subject.each { |value| value.should be_a_resource }}
-        context ":unique => false" do
-          subject {@enumerable.contexts(:unique => false)}
-          specify {subject.should be_an_enumerator}
-          specify {subject.each { |value| value.should be_a_resource }}
-        end
       end
+    end
 
-      it "should implement #has_context?" do
+    describe "#has_context?" do
+      it "has all contexts" do
+        checked = []
         @statements.each do |statement|
-          if statement.has_context?
-            @enumerable.has_context?(statement.context).should be_true
-          end
+          subject.should have_context(statement.context) if statement.has_context?
         end
         uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-        @enumerable.has_context?(uri).should be_false
+        subject.should_not have_context(uri)
       end
+    end
 
-      it "should implement #each_context" do
+    describe "#each_context" do
+      subject {@enumerable.each_context}
+      it {should be_an_enumerator}
+      it "has all contexts" 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)
+        subject.to_a.size.should == contexts.size
+        subject do |term|
+          term.should be_a_resource
+          contexts.should include(term)
         end
       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" 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}
-        specify {subject.should be_an_enumerator}
-        specify {subject.each { |value| value.should be_a_graph }}
+    describe "#enum_context" do
+      subject {@enumerable.enum_context}
+      it {should be_an_enumerator}
+      it {should be_countable}
+      it "should have all contexts" do
+        subject.to_a.should =~ @enumerable.each_context.to_a
       end
+    end
 
-      it "should implement #enum_graph" do
-        @enumerable.enum_graph.should be_an_enumerator
-        @enumerable.enum_graph.should be_countable
-        @enumerable.enum_graph.to_a.should == @enumerable.each_graph.to_a
+    describe "#each_graph" do
+      subject {@enumerable.each_graph}
+      it {should be_an_enumerator}
+      it "has all graphs" do
+        subject {|value| value.should be_a_graph}
       end
     end
 
-    context "when converting" do
-      it "should respond to #to_hash" do
-        @enumerable.should respond_to(:to_hash)
+    describe "#enum_graph" do
+      subject {@enumerable.enum_graph}
+      it {should be_an_enumerator}
+      it {should be_countable}
+      it "should have all graphs" do
+        subject.to_a.should =~ @enumerable.each_graph.to_a
       end
+    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
+    describe "#to_hash" do
+      subject {@enumerable.to_hash}
+      it {should be_a(Hash)}
+      it "should have keys for each subject" do
+        subject.keys.size.should == @enumerable.subjects.to_a.size
       end
     end
   
-    context "when dumping" do
-      it "should respond to #dump" do
-        @enumerable.should respond_to(:dump)
-      end
-    
-      it "should implement #dump" do
-        @enumerable.dump(:ntriples).should == RDF::NTriples::Writer.buffer() {|w| w << @enumerable}
+    describe "#dump" do
+      subject {@enumerable.dump(:ntriples)}
+      it "has N-Triples representation" do
+        subject.should == RDF::NTriples::Writer.buffer() {|w| w << @enumerable}
       end
-    
+      
       it "raises error on unknown format" do
         lambda {@enumerable.dump(:foobar)}.should raise_error(RDF::WriterError, /No writer found/)
       end
     end
+
+    context "#to_{writer}" do
+      it "should write to a writer" do
+        writer = mock("writer")
+        writer.should_receive(:buffer)
+        RDF::Writer.should_receive(:for).with(:a_writer).and_return(writer)
+        subject.send(:to_a_writer)
+      end
+    end
+
   end
 end

data/lib/rdf/spec/mutable.rb

@@ -17,6 +17,8 @@ module RDF_Mutable
   end
 
   describe RDF::Mutable do
+    subject {@mutable}
+
     context "readability" do
       require 'rdf/spec/readable'
 
@@ -37,119 +39,107 @@ 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_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 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 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)
+        lambda { subject.load(@filename) }.should_not raise_error(ArgumentError)
       end
 
       it "should accept an optional hash argument" do
-        lambda { @mutable.load(@filename,{}) }.should_not raise_error(ArgumentError)
+        lambda { subject.load(@filename, {}) }.should_not raise_error(ArgumentError)
       end
 
       it "should load statements" do
-        @mutable.load @filename
-        @mutable.size.should ==  File.readlines(@filename).size
-        @mutable.should have_subject(@subject)
+        subject.load @filename
+        subject.size.should ==  File.readlines(@filename).size
+        subject.should have_subject(@subject)
       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
+          subject.load @filename, :context => @context
+          subject.should have_context(@context)
+          subject.query(:context => @context).size.should == subject.size
         end
       end
     end
 
+    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
+
     context "when deleting statements" do
       before :each do
         @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
-        @mutable.insert(*@statements)
-      end
-
-      it "should support #delete" do
-        @mutable.should respond_to(:delete)
+        subject.insert(*@statements)
       end
 
       it "should not raise errors" do
-        lambda { @mutable.delete(@statements.first) }.should_not raise_error
+        lambda { subject.delete(@statements.first) }.should_not raise_error
       end
 
       it "should support deleting one statement at a time" do
-        @mutable.delete(@statements.first)
-        @mutable.should_not have_statement(@statements.first)
+        subject.delete(@statements.first)
+        subject.should_not have_statement(@statements.first)
       end
 
       it "should support deleting multiple statements at a time" do
-        @mutable.delete(*@statements)
-        @statements.find { |s| @mutable.has_statement?(s) }.should be_false
+        subject.delete(*@statements)
+        subject.find { |s| subject.has_statement?(s) }.should be_false
       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
+        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
-        @mutable.delete([nil, nil, nil])
-        @mutable.should be_empty
+        subject.delete([nil, nil, nil])
+        subject.should be_empty
       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)
+        count = subject.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
+        subject.insert(s1)
+        subject.insert(s2)
+        subject.insert(s3)
+        subject.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)
+        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

metadata

@@ -1,68 +1,67 @@
 --- !ruby/object:Gem::Specification
 name: rdf-spec
 version: !ruby/object:Gem::Version
-  version: 1.0.0
-  prerelease: 
+  version: 1.0.5
+  prerelease:
 platform: ruby
 authors:
 - Arto Bendiken
 - Ben Lavender
 - Gregg Kellogg
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-01-19 00:00:00.000000000 Z
+date: 2013-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
-  requirement: !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
     none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+    none: false
+  prerelease: false
+  type: :development
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.12'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
     none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.12'
+    none: false
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.8'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
     none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.8'
-description: RDF.rb plugin that provides RSpec matchers and shared examples for RDF
-  objects.
+    none: false
+  prerelease: false
+  type: :development
+description: RDF.rb plugin that provides RSpec matchers and shared examples for RDF objects.
 email: public-rdf-ruby@w3.org
 executables: []
 extensions: []
@@ -86,6 +85,7 @@ files:
 - etc/gkellogg.nt
 - etc/gkellogg.ttl
 - etc/test-data.nt
+- lib/rdf/spec.rb
 - lib/rdf/spec/countable.rb
 - lib/rdf/spec/durable.rb
 - lib/rdf/spec/enumerable.rb
@@ -102,32 +102,32 @@ files:
 - lib/rdf/spec/version.rb
 - lib/rdf/spec/writable.rb
 - lib/rdf/spec/writer.rb
-- lib/rdf/spec.rb
 - spec/spec_helper.rb
 - spec/version_spec.rb
 homepage: http://github.com/ruby-rdf/rdf-spec/
 licenses:
 - Public Domain
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.8.1
-required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: !binary |-
+        MA==
+  none: false
 requirements: []
 rubyforge_project: rdf
 rubygems_version: 1.8.24
-signing_key: 
+signing_key:
 specification_version: 3
 summary: RSpec extensions for RDF.rb.
 test_files: []