rdf-spec 1.0.9 → 1.1.0.p1

data/lib/rdf/spec/format.rb

@@ -9,33 +9,32 @@ 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
-          expect(RDF::Format.for("foo.#{ext}")).to eq formats.first
+          RDF::Format.for("foo.#{ext}").should == formats.first
         end
 
         it "detects #{formats.first} using file_name foo.#{ext}" do
-          expect(RDF::Format.for(:file_name => "foo.#{ext}")).to eq formats.first
+          RDF::Format.for(:file_name => "foo.#{ext}").should == formats.first
         end
 
         it "detects #{formats.first} using file_extension #{ext}" do
-          expect(RDF::Format.for(:file_extension => ext)).to eq formats.first
+          RDF::Format.for(:file_extension => ext).should == formats.first
         end
       end
 
       RDF::Format.content_types.each do |content_type, formats|
         it "detects #{formats.first} using content_type #{content_type}" do
-          expect(RDF::Format.for(:content_type => content_type)).to eq formats.first
+          RDF::Format.for(:content_type => content_type).should == formats.first
         end
       end
     end
   
     describe ".reader" do
       it "returns a reader" do
-        subject.each do |f|
-          expect(f.reader).not_to  be_nil
+        @format_class.each do |f|
+          f.reader.should_not be_nil
         end
       end
     end
@@ -44,9 +43,9 @@ module RDF_Format
       ##
       # May not return a writer, only does if one is defined by the format
       it "returns a writer" do
-        subject.each do |f|
+        @format_class.each do |f|
           format_namespace = f.name.split('::')[0..-2].inject(Kernel) {|base, const| base.const_get(const)}
-          expect(f.writer).not_to  be_nil if format_namespace.const_defined?(:Writer)
+          f.writer.should_not be_nil if format_namespace.const_defined?(:Writer)
         end
       end
     end

data/lib/rdf/spec/indexable.rb

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

data/lib/rdf/spec/matchers.rb

@@ -8,113 +8,113 @@ module RDF; module Spec
   module Matchers
     RSpec::Matchers.define :be_countable do
       match do |countable|
-        expect(countable).to be_a_kind_of(RDF::Countable)
+        countable.should be_a_kind_of(RDF::Countable)
         true
       end
     end
 
     RSpec::Matchers.define :be_enumerable do
       match do |enumerable|
-        expect(enumerable).to be_a_kind_of(RDF::Enumerable)
+        enumerable.should be_a_kind_of(RDF::Enumerable)
         true
       end
     end
 
     RSpec::Matchers.define :be_an_enumerator do
       match do |enumerator|
-        expect(enumerator).to be_a_kind_of(RDF::Enumerator)
+        enumerator.should be_a_kind_of(Enumerator)
         true
       end
     end
 
     RSpec::Matchers.define :be_queryable do
       match do |enumerable|
-        expect(enumerable).to be_a_kind_of(RDF::Queryable)
+        enumerable.should be_a_kind_of(RDF::Queryable)
         true
       end
     end
 
     RSpec::Matchers.define :be_mutable do
       match do |enumerable|
-        expect(enumerable).to be_a_kind_of(RDF::Mutable)
+        enumerable.should be_a_kind_of(RDF::Mutable)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_statement do
       match do |statement|
-        expect(statement).to be_instance_of(RDF::Statement)
-        expect(statement.subject).to be_a_kind_of(RDF::Resource)
-        expect(statement.predicate).to be_a_kind_of(RDF::URI)
-        expect(statement.object).to be_a_kind_of(RDF::Value)
+        statement.should be_instance_of(RDF::Statement)
+        statement.subject.should be_a_kind_of(RDF::Resource)
+        statement.predicate.should be_a_kind_of(RDF::URI)
+        statement.object.should be_a_kind_of(RDF::Value)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_triple do
       match do |triple|
-        expect(triple).to be_instance_of(Array)
-        expect(triple.size).to eq 3
-        expect(triple[0]).to be_a_kind_of(RDF::Resource)
-        expect(triple[1]).to be_a_kind_of(RDF::URI)
-        expect(triple[2]).to be_a_kind_of(RDF::Value)
+        triple.should be_instance_of(Array)
+        triple.size.should == 3
+        triple[0].should be_a_kind_of(RDF::Resource)
+        triple[1].should be_a_kind_of(RDF::URI)
+        triple[2].should be_a_kind_of(RDF::Value)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_quad do
       match do |quad|
-        expect(quad).to be_instance_of(Array)
-        expect(quad.size).to eq 4
-        expect(quad[0]).to be_a_kind_of(RDF::Resource)
-        expect(quad[1]).to be_a_kind_of(RDF::URI)
-        expect(quad[2]).to be_a_kind_of(RDF::Value)
-        expect(quad[3]).to be_a_kind_of(RDF::Resource) unless quad[3].nil?
+        quad.should be_instance_of(Array)
+        quad.size.should == 4
+        quad[0].should be_a_kind_of(RDF::Resource)
+        quad[1].should be_a_kind_of(RDF::URI)
+        quad[2].should be_a_kind_of(RDF::Value)
+        quad[3].should be_a_kind_of(RDF::Resource) unless quad[3].nil?
         true
       end
     end
 
     RSpec::Matchers.define :be_a_resource do
       match do |value|
-        expect(value).to be_a_kind_of(RDF::Resource)
+        value.should be_a_kind_of(RDF::Resource)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_node do
       match do |value|
-        expect(value).to be_a_kind_of(RDF::Node)
+        value.should be_a_kind_of(RDF::Node)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_uri do
       match do |value|
-        expect(value).to be_a_kind_of(RDF::URI)
+        value.should be_a_kind_of(RDF::URI)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_value do
       match do |value|
-        expect(value).to be_a_kind_of(RDF::Value)
+        value.should be_a_kind_of(RDF::Value)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_list do
       match do |value|
-        expect(value).to be_an(RDF::List)
+        value.should be_an(RDF::List)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_vocabulary do |base_uri|
       match do |vocabulary|
-        expect(vocabulary).to be_a_kind_of(Module)
-        expect(vocabulary).to respond_to(:to_uri)
-        expect(vocabulary.to_uri.to_s).to eq base_uri
-        expect(vocabulary).to respond_to(:[])
+        vocabulary.should be_a_kind_of(Module)
+        vocabulary.should respond_to(:to_uri)
+        vocabulary.to_uri.to_s.should == base_uri
+        vocabulary.should respond_to(:[])
         true
       end
     end
@@ -122,13 +122,13 @@ module RDF; module Spec
     RSpec::Matchers.define :have_properties do |base_uri, properties|
       match do |vocabulary|
         properties.map { |p| p.to_sym }.each do |property|
-          expect(vocabulary[property]).to be_a_uri
-          expect(vocabulary[property].to_s).to eq "#{base_uri}#{property}"
-          expect(vocabulary).to respond_to(property)
-          expect { vocabulary.send(property) }.not_to raise_error
-          expect(vocabulary.send(property)).to be_a_uri
-          expect(vocabulary.send(property.to_s)).to be_a_uri
-          expect(vocabulary.send(property).to_s).to eq "#{base_uri}#{property}"
+          vocabulary[property].should be_a_uri
+          vocabulary[property].to_s.should == "#{base_uri}#{property}"
+          vocabulary.should respond_to(property)
+          lambda { vocabulary.send(property) }.should_not raise_error
+          vocabulary.send(property).should be_a_uri
+          vocabulary.send(property.to_s).should be_a_uri
+          vocabulary.send(property).to_s.should == "#{base_uri}#{property}"
         end
         true
       end
@@ -145,14 +145,14 @@ module RDF; module Spec
 
     RSpec::Matchers.define :be_a_repository do
       match do |repository|
-        expect(repository).to be_a_kind_of(RDF::Repository)
+        repository.should be_a_kind_of(RDF::Repository)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_repository_of_size do |size|
       match do |repository|
-        expect(repository).to be_a_repository
+        repository.should be_a_repository
         repository.size == size
       end
     end

data/lib/rdf/spec/mutable.rb

@@ -8,14 +8,15 @@ 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'
 
@@ -36,123 +37,119 @@ module RDF_Mutable
       include RDF_Writable
     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 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
 
-    its(:count) {should be_zero}
+    it "should support #load" do
+      @mutable.respond_to?(:load).should be_true
+    end
 
     context "#load" do
       it "should require an argument" do
-        expect { subject.load }.to raise_error(ArgumentError)
+        lambda { @mutable.load }.should raise_error(ArgumentError)
       end
 
       it "should accept a string filename argument" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
-        end
+        lambda { @mutable.load(@filename) }.should_not raise_error(ArgumentError)
       end
 
       it "should accept an optional hash argument" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
-        end
+        lambda { @mutable.load(@filename,{}) }.should_not raise_error(ArgumentError)
       end
 
       it "should load statements" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.load RDF::Spec::TRIPLES_FILE
-          expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
-          expect(subject).to have_subject(resource)
-        end
+        @mutable.load @filename
+        @mutable.size.should ==  File.readlines(@filename).size
+        @mutable.should have_subject(@subject)
       end
 
       it "should load statements with a context override" do
-        pending("mutability and contextuality", :unless => (subject.mutable? && @supports_context)) do
-          subject.load RDF::Spec::TRIPLES_FILE, :context => context
-          expect(subject).to have_context(context)
-          expect(subject.query(:context => context).size).to eq subject.size
+        if @supports_context
+          @mutable.load @filename, :context => @context
+          @mutable.should have_context(@context)
+          @mutable.query(:context => @context).size.should == @mutable.size
         end
       end
     end
 
-    context "#from_{reader}" do
-      it "should instantiate a reader" do
-        reader = double("reader")
-        expect(reader).to receive(:new).and_return(RDF::NTriples::Reader.new(""))
-        expect(RDF::Reader).to 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(RDF::Spec::TRIPLES_FILE)).to_a
-        subject.insert(*@statements)
+        @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+        @mutable.insert(*@statements)
+      end
+
+      it "should support #delete" do
+        @mutable.should respond_to(:delete)
       end
 
       it "should not raise errors" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.delete(@statements.first) }.not_to raise_error
-        end
+        lambda { @mutable.delete(@statements.first) }.should_not raise_error
       end
 
       it "should support deleting one statement at a time" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.delete(@statements.first)
-          expect(subject).not_to  have_statement(@statements.first)
-        end
+        @mutable.delete(@statements.first)
+        @mutable.should_not have_statement(@statements.first)
       end
 
       it "should support deleting multiple statements at a time" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.delete(*@statements)
-          expect(subject.find { |s| subject.has_statement?(s) }).to be_false
-        end
+        @mutable.delete(*@statements)
+        @statements.find { |s| @mutable.has_statement?(s) }.should be_false
       end
 
       it "should support wildcard deletions" do
-        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__))])
-          expect(subject).not_to  be_empty
-          expect(subject.count).to eq count
-
-          # everything deleted
-          subject.delete([nil, nil, nil])
-          expect(subject).to be_empty
-        end
+        # 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
       end
 
       it "should only delete statements when the context matches" do
-        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)
-          expect(subject.count).to eq count
-
-          # Delete one by one
-          subject.delete(s1)
-          expect(subject.count).to eq count - (@supports_context ? 1 : 1)
-          subject.delete(s2)
-          expect(subject.count).to eq count - (@supports_context ? 2 : 1)
-          subject.delete(s3)
-          expect(subject.count).to eq count - (@supports_context ? 3 : 1)
-        end
+        # 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)
       end
     end
   end