rdf-spec 0.3.8 → 0.3.9

data/lib/rdf/spec/format.rb

@@ -1,49 +1,52 @@
 require 'rdf/spec'
 
-share_as :RDF_Format do
+module RDF_Format
+  extend RSpec::SharedContext
   include RDF::Spec::Matchers
 
   before(:each) do
     raise raise '+@format_class+ must be defined in a before(:each) block' unless instance_variable_get('@format_class')
   end
 
-  describe ".for" do
-    RDF::Format.file_extensions.each do |ext, formats|
-      it "detects #{formats.first} using file path foo.#{ext}" do
-        RDF::Format.for("foo.#{ext}").should == formats.first
-      end
+  describe RDF::Format do
+    describe ".for" do
+      RDF::Format.file_extensions.each do |ext, formats|
+        it "detects #{formats.first} using file path foo.#{ext}" do
+          RDF::Format.for("foo.#{ext}").should == formats.first
+        end
 
-      it "detects #{formats.first} using file_name foo.#{ext}" do
-        RDF::Format.for(:file_name => "foo.#{ext}").should == formats.first
-      end
+        it "detects #{formats.first} using file_name foo.#{ext}" do
+          RDF::Format.for(:file_name => "foo.#{ext}").should == formats.first
+        end
 
-      it "detects #{formats.first} using file_extension #{ext}" do
-        RDF::Format.for(:file_extension => ext).should == formats.first
+        it "detects #{formats.first} using file_extension #{ext}" do
+          RDF::Format.for(:file_extension => ext).should == formats.first
+        end
       end
-    end
 
-    RDF::Format.content_types.each do |content_type, formats|
-      it "detects #{formats.first} using content_type #{content_type}" do
-        RDF::Format.for(:content_type => content_type).should == formats.first
+      RDF::Format.content_types.each do |content_type, formats|
+        it "detects #{formats.first} using content_type #{content_type}" do
+          RDF::Format.for(:content_type => content_type).should == formats.first
+        end
       end
     end
-  end
   
-  describe ".reader" do
-    it "returns a reader" do
-      @format_class.each do |f|
-        f.reader.should_not be_nil
+    describe ".reader" do
+      it "returns a reader" do
+        @format_class.each do |f|
+          f.reader.should_not be_nil
+        end
       end
     end
-  end
   
-  describe ".writer" do
-    ##
-    # May not return a writer, only does if one is defined by the format
-    it "returns a writer" do
-      @format_class.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)
+    describe ".writer" do
+      ##
+      # May not return a writer, only does if one is defined by the format
+      it "returns a writer" do
+        @format_class.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
       end
     end
   end

data/lib/rdf/spec/indexable.rb

@@ -1,29 +1,32 @@
 require 'rdf/spec'
 
-share_as :RDF_Indexable do
+module RDF_Indexable
+  extend RSpec::SharedContext
   include RDF::Spec::Matchers
 
   before :each do
     raise '+@indexable+ must be defined in a before(:each) block' unless instance_variable_get('@indexable')
   end
+
+  describe RDF::Indexable do
+    it "responds to #indexed?" do
+      @indexable.respond_to?(:indexed?)
+    end
   
-  it "responds to #indexed?" do
-    @indexable.respond_to?(:indexed?)
-  end
-  
-  it "implements #indexed?" do
-    !!@indexable.indexed?.should == @indexable.indexed?
-  end
+    it "implements #indexed?" do
+      !!@indexable.indexed?.should == @indexable.indexed?
+    end
   
-  it "responds to #index!" do
-    @indexable.respond_to?(:index!)
-  end
+    it "responds to #index!" do
+      @indexable.respond_to?(:index!)
+    end
   
-  it "does not raise error on #index! if #indexed?" do
-    lambda {@indexable.index!}.should_not raise_error if @indexable.indexed?
-  end
+    it "does not raise error on #index! if #indexed?" do
+      lambda {@indexable.index!}.should_not raise_error if @indexable.indexed?
+    end
   
-  it "raises error on #index! if not #indexed?" do
-    lambda {@indexable.index!}.should raise_error unless @indexable.indexed?
+    it "raises error on #index! if not #indexed?" do
+      lambda {@indexable.index!}.should raise_error unless @indexable.indexed?
+    end
   end
 end

data/lib/rdf/spec/inferable.rb

@@ -1,7 +1,10 @@
 require 'rdf/spec'
 
-share_as :RDF_Inferable do
+module RDF_Inferable
+  extend RSpec::SharedContext
   include RDF::Spec::Matchers
 
-  # TODO
+  describe RDF::Inferable do
+    it "should implement specs" #TODO
+  end
 end

data/lib/rdf/spec/matchers.rb

@@ -46,7 +46,7 @@ module RDF; module Spec
         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) unless statement.object.is_a?(String) # FIXME
+        statement.object.should be_a_kind_of(RDF::Value)
         true
       end
     end
@@ -57,7 +57,7 @@ module RDF; module Spec
         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) unless triple[2].is_a?(String) # FIXME
+        triple[2].should be_a_kind_of(RDF::Value)
         true
       end
     end
@@ -68,7 +68,7 @@ module RDF; module Spec
         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) unless quad[2].is_a?(String) # FIXME
+        quad[2].should be_a_kind_of(RDF::Value)
         quad[3].should be_a_kind_of(RDF::Resource) unless quad[3].nil?
         true
       end
@@ -97,7 +97,7 @@ module RDF; module Spec
 
     RSpec::Matchers.define :be_a_value do
       match do |value|
-        value.should be_a_kind_of(RDF::Value) unless value.is_a?(String) # FIXME
+        value.should be_a_kind_of(RDF::Value)
         true
       end
     end
@@ -124,7 +124,7 @@ module RDF; module Spec
         properties.map { |p| p.to_sym }.each do |property|
           vocabulary[property].should be_a_uri
           vocabulary[property].to_s.should == "#{base_uri}#{property}"
-          #vocabulary.should respond_to(property) # FIXME
+          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
@@ -137,7 +137,7 @@ module RDF; module Spec
     RSpec::Matchers.define :have_subclasses do |base_uri, klasses|
       match do |vocabulary|
         klasses.map { |k| k.to_sym }.each do |klass|
-          # TODO
+          pending "checks that #{base_uri} has subClassOf for #{klass}"
         end
         true
       end

data/lib/rdf/spec/mutable.rb

@@ -1,7 +1,8 @@
 require 'rdf/spec'
 require 'rdf/ntriples'
 
-share_as :RDF_Mutable do
+module RDF_Mutable
+  extend RSpec::SharedContext
   include RDF::Spec::Matchers
 
   before :each do
@@ -15,139 +16,141 @@ share_as :RDF_Mutable do
     @supports_context = @mutable.respond_to?(:supports?) && @mutable.supports?(:context)
   end
 
-  context "readability" do
-    require 'rdf/spec/readable'
+  describe RDF::Mutable do
+    context "readability" do
+      require 'rdf/spec/readable'
 
-    before :each do
-      @readable = @mutable
-    end
-
-    it_should_behave_like RDF_Readable
-  end
-
-  context "writability" do
-    require 'rdf/spec/writable'
+      before :each do
+        @readable = @mutable
+      end
 
-    before :each do
-      @writable = @mutable
+      include RDF_Readable
     end
 
-    it_should_behave_like 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
+    context "writability" do
+      require 'rdf/spec/writable'
 
-  it "should be writable" do
-    @mutable.writable?.should be_true
-  end
+      before :each do
+        @writable = @mutable
+      end
 
-  it "should be mutable" do
-    @mutable.immutable?.should be_false
-    @mutable.mutable?.should be_true
-  end
+      include RDF_Writable
+    end
 
-  it "should support #load" do
-    @mutable.respond_to?(:load).should be_true
-  end
+    it "should be empty initially" do
+      @mutable.empty?.should be_true
+      @mutable.count.should be_zero
+    end
 
-  context "#load" do
-    it "should require an argument" do
-      lambda { @mutable.load }.should raise_error(ArgumentError)
+    it "should be readable" do
+      @mutable.readable?.should be_true
     end
 
-    it "should accept a string filename argument" do
-      lambda { @mutable.load(@filename) }.should_not raise_error(ArgumentError)
+    it "should be writable" do
+      @mutable.writable?.should be_true
     end
 
-    it "should accept an optional hash argument" do
-      lambda { @mutable.load(@filename,{}) }.should_not raise_error(ArgumentError)
+    it "should be mutable" do
+      @mutable.immutable?.should be_false
+      @mutable.mutable?.should be_true
     end
 
-    it "should load statements" do
-      @mutable.load @filename
-      @mutable.size.should ==  File.readlines(@filename).size
-      @mutable.should have_subject(@subject)
+    it "should support #load" do
+      @mutable.respond_to?(:load).should be_true
     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
+    context "#load" do
+      it "should require an argument" do
+        lambda { @mutable.load }.should raise_error(ArgumentError)
       end
-    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 accept a string filename argument" do
+        lambda { @mutable.load(@filename) }.should_not raise_error(ArgumentError)
+      end
 
-    it "should support #delete" do
-      @mutable.should respond_to(:delete)
-    end
+      it "should accept an optional hash argument" do
+        lambda { @mutable.load(@filename,{}) }.should_not raise_error(ArgumentError)
+      end
 
-    it "should not raise errors" do
-      lambda { @mutable.delete(@statements.first) }.should_not raise_error
-    end
+      it "should load statements" do
+        @mutable.load @filename
+        @mutable.size.should ==  File.readlines(@filename).size
+        @mutable.should have_subject(@subject)
+      end
 
-    it "should support deleting one statement at a time" do
-      @mutable.delete(@statements.first)
-      @mutable.should_not have_statement(@statements.first)
+      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
+        end
+      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
-    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 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
-    end
+      it "should support #delete" do
+        @mutable.should respond_to(:delete)
+      end
+
+      it "should not raise errors" do
+        lambda { @mutable.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)
+      end
+
+      it "should support deleting multiple statements at a time" do
+        @mutable.delete(*@statements)
+        @statements.find { |s| @mutable.has_statement?(s) }.should be_false
+      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)
+      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
+      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
-  end
 
-  context "when clearing all statements" do
-    it "should support #clear" do
-      @mutable.should respond_to(:clear)
+    context "when clearing all statements" do
+      it "should support #clear" do
+        @mutable.should respond_to(:clear)
+      end
     end
   end
 end