rdf-spec 0.1.10 → 0.2.0

data/lib/rdf/spec/graph.rb

@@ -41,6 +41,16 @@ share_as :RDF_Graph do
       graph.context.should_not be_nil
       graph.contexts.size.should == 1
     end
+
+    it "should be #anonymous? with a Node context" do
+      graph = @new.call(RDF::Node.new)
+      graph.should be_anonymous
+    end
+
+    it "should not be #anonymous? with a URI context" do
+      graph = @new.call("http://rdf.rubyforge.org/")
+      graph.should_not be_anonymous
+    end
   end
 
 end

data/lib/rdf/spec/literal.rb

@@ -51,6 +51,10 @@ share_as :RDF_Literal do
       @empty.to_s.should eql('""')
       @hello.to_s.should eql('"Hello"')
     end
+
+    it "should not be #anonymous?" do
+      @hello.should_not be_anonymous
+    end
   end
 
   context "languaged-tagged literals" do

data/lib/rdf/spec/matchers.rb

@@ -17,6 +17,41 @@ module RDF; module Spec
       end
     end
 
+    define :be_countable do
+      match do |countable|
+        countable.should be_a_kind_of(RDF::Countable)
+        true
+      end
+    end
+
+    define :be_enumerable do
+      match do |enumerable|
+        enumerable.should be_a_kind_of(RDF::Enumerable)
+        true
+      end
+    end
+
+    define :be_an_enumerator do
+      match do |enumerator|
+        enumerator.should be_a_kind_of(RDF::Enumerator)
+        true
+      end
+    end
+
+    define :be_queryable do
+      match do |enumerable|
+        enumerable.should be_a_kind_of(RDF::Queryable)
+        true
+      end
+    end
+
+    define :be_mutable do
+      match do |enumerable|
+        enumerable.should be_a_kind_of(RDF::Mutable)
+        true
+      end
+    end
+
     define :be_a_statement do
       match do |statement|
         statement.should be_instance_of(RDF::Statement)
@@ -90,7 +125,7 @@ module RDF; module Spec
 
     define :have_properties do |base_uri, properties|
       match do |vocabulary|
-        properties.map(&:to_sym).each do |property|
+        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
@@ -105,7 +140,7 @@ module RDF; module Spec
 
     define :have_subclasses do |base_uri, klasses|
       match do |vocabulary|
-        klasses.map(&:to_sym).each do |klass|
+        klasses.map { |k| k.to_sym }.each do |klass|
           # TODO
         end
         true

data/lib/rdf/spec/mutable.rb

@@ -3,61 +3,65 @@ require 'rdf/spec'
 require 'rdf/ntriples'
 
 share_as :RDF_Mutable do
-
   include RDF::Spec::Matchers
 
   before :each do
-    raise '+@filename+ must be defined in a before(:each) block' unless instance_variable_get('@filename')
-    raise '+@repository+ must be defined in a before(:each) block' unless instance_variable_get('@repository')
-    raise '+@subject+ must be defined in a before(:each) block' unless instance_variable_get('@subject')
-    raise '+@context+ must be defined in a before(:each) block' unless instance_variable_get('@context')
+    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')
+
+    # Assume contexts are supported unless declared otherwise:
+    @supports_context = @mutable.respond_to?(:supports?) ? @mutable.supports?(:context) : true
   end
 
   it "should be empty initially" do
-    @repository.empty?.should be_true
-    @repository.count.should be_zero
+    @mutable.empty?.should be_true
+    @mutable.count.should be_zero
   end
 
   it "should be readable" do
-    @repository.readable?.should be_true
+    @mutable.readable?.should be_true
   end
 
   it "should be writable" do
-    @repository.writable?.should be_true
+    @mutable.writable?.should be_true
   end
 
   it "should be mutable" do
-    @repository.immutable?.should be_false
-    @repository.mutable?.should be_true
+    @mutable.immutable?.should be_false
+    @mutable.mutable?.should be_true
   end
 
   it "should support #load" do
-    @repository.respond_to?(:load).should be_true
+    @mutable.respond_to?(:load).should be_true
   end
 
   context "#load" do
     it "should require an argument" do
-      lambda { @repository.load }.should raise_error(ArgumentError)
+      lambda { @mutable.load }.should raise_error(ArgumentError)
     end
 
     it "should accept a string filename argument" do
-      lambda { @repository.load(@filename) }.should_not raise_error(ArgumentError)
+      lambda { @mutable.load(@filename) }.should_not raise_error(ArgumentError)
     end
 
     it "should accept an optional hash argument" do
-      lambda { @repository.load(@filename,{}) }.should_not raise_error(ArgumentError)
+      lambda { @mutable.load(@filename,{}) }.should_not raise_error(ArgumentError)
     end
 
     it "should load statements" do
-      @repository.load @filename
-      @repository.size.should ==  File.readlines(@filename).size
-      @repository.should have_subject @subject
+      @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
-      @repository.load @filename, :context => @context
-      @repository.should have_context @context
-      @repository.query(:context => @context).size.should == @repository.size
+      @mutable.load @filename, :context => @context
+      @mutable.should have_context @context
+      @mutable.query(:context => @context).size.should == @mutable.size
     end
   end
 
@@ -67,75 +71,112 @@ share_as :RDF_Mutable do
     end
 
     it "should support #insert" do
-      @repository.should respond_to(:insert)
+      @mutable.should respond_to(:insert)
     end
 
     it "should not raise errors" do
-      lambda { @repository.insert(@statements.first) }.should_not raise_error
+      lambda { @mutable.insert(@statements.first) }.should_not raise_error
     end
 
     it "should support inserting one statement at a time" do
-      @repository.insert(@statements.first)
-      @repository.should have_statement(@statements.first)
+      @mutable.insert(@statements.first)
+      @mutable.should have_statement(@statements.first)
     end
 
     it "should support inserting multiple statements at a time" do
-      @repository.insert(*@statements)
+      @mutable.insert(*@statements)
     end
 
     it "should insert statements successfully" do
-      @repository.insert(*@statements)
-      @repository.count.should == @statements.size
+      @mutable.insert(*@statements)
+      @mutable.count.should == @statements.size
     end
 
     it "should not insert a statement twice" do
-      @repository.insert(@statements.first)
-      @repository.insert(@statements.first)
-      @repository.count.should == 1
+      @mutable.insert(@statements.first)
+      @mutable.insert(@statements.first)
+      @mutable.count.should == 1
     end
+
+    it "should treat statements with a different context as distinct" do
+      s1 = @statements.first.dup
+      s1.context = nil
+      s2 = @statements.first.dup
+      s2.context = RDF::URI.new("urn:context:1")
+      s3 = @statements.first.dup
+      s3.context = RDF::URI.new("urn:context:2")
+      @mutable.insert(s1)
+      @mutable.insert(s2)
+      @mutable.insert(s3)
+      # If contexts are not suported, all three are redundant
+      @mutable.count.should == (@supports_context ? 3 : 1)
+    end
+
   end
 
   context "when deleting statements" do
     before :each do
       @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
-      @repository.insert(*@statements)
+      @mutable.insert(*@statements)
     end
 
     it "should support #delete" do
-      @repository.should respond_to(:delete)
+      @mutable.should respond_to(:delete)
     end
 
     it "should not raise errors" do
-      lambda { @repository.delete(@statements.first) }.should_not raise_error
+      lambda { @mutable.delete(@statements.first) }.should_not raise_error
     end
 
     it "should support deleting one statement at a time" do
-      @repository.delete(@statements.first)
-      @repository.should_not have_statement(@statements.first)
+      @mutable.delete(@statements.first)
+      @mutable.should_not have_statement(@statements.first)
     end
 
     it "should support deleting multiple statements at a time" do
-      @repository.delete(*@statements)
-      @statements.find { |s| @repository.has_statement?(s) }.should be_false
+      @mutable.delete(*@statements)
+      @statements.find { |s| @mutable.has_statement?(s) }.should be_false
     end
 
     it "should support wildcard deletions" do
       # nothing deleted
       require 'digest/sha1'
-      count = @repository.count
-      @repository.delete([nil, nil, random = Digest::SHA1.hexdigest(File.read(__FILE__))])
-      @repository.should_not be_empty
-      @repository.count.should == count
+      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
-      @repository.delete([nil, nil, nil])
-      @repository.should be_empty
+      @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
 
   context "when clearing all statements" do
     it "should support #clear" do
-      @repository.should respond_to(:clear)
+      @mutable.should respond_to(:clear)
     end
   end
 end

data/lib/rdf/spec/queryable.rb

@@ -5,53 +5,89 @@ share_as :RDF_Queryable do
   include RDF::Spec::Matchers
 
   before :each do
-    # RDF::Queryable cares about the contents of this file too much to let someone set it
-    @filename = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
     raise '+@queryable+ must be defined in a before(:each) block' unless instance_variable_get('@queryable')
-    raise '+@subject+ must be defined in a before(:each) block' unless instance_variable_get('@subject')
+
+    @filename = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
+    @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+
     if @queryable.empty?
-      if @queryable.respond_to?(:insert)
-        @queryable.insert(*(RDF::NTriples::Reader.new(File.open(@filename)).to_a))
+      if @queryable.respond_to?(:<<)
+        @statements.each { |statement| @queryable << statement }
       else
-        raise "@queryable must be mutable or pre-populated with the statements in #{@filename} in a before(:each)"
+        raise "@queryable must respond to #<< or be pre-populated with the statements in #{@filename} in a before(:each) block"
       end
     end
+
+    @subject = RDF::URI('http://rubygems.org/gems/rdf')
   end
 
   ##
   # @see RDF::Queryable#query
 
-  it "should support #query" do
-    @queryable.respond_to?(:query).should be_true
+  it "should respond to #query" do
+    @queryable.should respond_to(:query)
   end
 
-  context "#query" do
+  context "#query when called" do
     it "should require an argument" do
       lambda { @queryable.query }.should raise_error(ArgumentError)
     end
 
+    it "should accept 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)
+    end
+
+    it "should accept a statement argument" do
+      lambda { @queryable.query(RDF::Statement.new(nil, nil, nil)) }.should_not raise_error(ArgumentError)
+    end
+
     it "should accept a triple argument" do
       lambda { @queryable.query([nil, nil, nil]) }.should_not raise_error(ArgumentError)
     end
 
+    it "should accept a quad argument" do
+      lambda { @queryable.query([nil, nil, nil, nil]) }.should_not raise_error(ArgumentError)
+    end
+
     it "should accept a hash argument" do
       lambda { @queryable.query({}) }.should_not raise_error(ArgumentError)
     end
 
-    it "should accept a statement argument" do
-      lambda { @queryable.query(RDF::Statement.new(nil, nil, nil)) }.should_not raise_error(ArgumentError)
+    it "should not alter a given hash argument" do
+      query = {:subject => @subject, :predicate => RDF::DOAP.name, :object => RDF::FOAF.Person}
+      original_query = query.dup
+      @queryable.query(query)
+      query.should == original_query
     end
 
-    it "should accept 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)
+    it "should reject other kinds of arguments" do
+      lambda { @queryable.query(nil) }.should raise_error(ArgumentError)
+    end
+  end
+
+  context "#query when called with a block" do
+    it "should yield statements" do
+      @queryable.query([nil, nil, nil]) do |statement|
+        statement.should be_a_statement
+      end
     end
+  end
 
-    it "should reject other arguments" do
-      lambda { @queryable.query(nil) }.should raise_error(ArgumentError)
+  context "#query when called without a block" do
+    it "should return an enumerator" do
+      @queryable.query([nil, nil, nil]).should be_a_kind_of(RDF::Enumerator)
+    end
+
+    it "should return an enumerable enumerator" do
+      @queryable.query([nil, nil, nil]).should be_a_kind_of(RDF::Enumerable)
+    end
+
+    it "should return a queryable enumerator" do
+      @queryable.query([nil, nil, nil]).should be_a_kind_of(RDF::Queryable)
     end
 
-    it "should return RDF statements" do
+    it "should return statements" do
       @queryable.query([nil, nil, nil]).each do |statement|
         statement.should be_a_statement
       end
@@ -61,7 +97,7 @@ share_as :RDF_Queryable do
       @queryable.query([nil, nil, nil]).size.should == File.readlines(@filename).size
       @queryable.query([@subject, nil, nil]).size.should == File.readlines(@filename).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
       @queryable.query([@subject, RDF::DOAP.name, nil]).size.should == 1
-      @queryable.query([@subject, RDF::DOAP.developer, nil]).size.should == @queryable.query([nil, nil, RDF::FOAF.Person]).size
+      #@queryable.query([@subject, RDF::DOAP.developer, nil]).size.should == @queryable.query([nil, nil, RDF::FOAF.Person]).size # FIXME: assumes too much about the doap.nt data
       @queryable.query([nil, nil, RDF::DOAP.Project]).size.should == 1
     end
 
@@ -69,23 +105,44 @@ share_as :RDF_Queryable do
       @queryable.query({}).size.should == File.readlines(@filename).size
       @queryable.query(:subject => @subject) .size.should == File.readlines(@filename).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
       @queryable.query(:subject => @subject, :predicate => RDF::DOAP.name).size.should == 1
-      @queryable.query(:subject => @subject, :predicate => RDF::DOAP.developer).size.should == @queryable.query(:object => RDF::FOAF.Person).size
+      #@queryable.query(:subject => @subject, :predicate => RDF::DOAP.developer).size.should == @queryable.query(:object => RDF::FOAF.Person).size # FIXME: assumes too much about the doap.nt data
       @queryable.query(:object => RDF::DOAP.Project).size.should == 1
     end
+  end
 
-    it "should not alter a given hash argument" do
-      query = {:subject => @subject, :predicate => RDF::DOAP.name, :object => RDF::FOAF.Person}
-      original_query = query.dup
-      result = @queryable.query(query)
-      query.should == original_query
+  ##
+  # @see RDF::Queryable#query_pattern
+
+  it "should respond to #query_pattern" do
+    @queryable.should respond_to(:query_pattern)
+  end
+
+  context "#query_pattern when called" do
+    it "should require an argument" do
+      lambda { @queryable.send(:query_pattern) }.should raise_error(ArgumentError)
+    end
+
+    it "should call the given block" do
+      called = false
+      @queryable.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
+        called = true
+        break
+      end
+      called.should be_true
+    end
+
+    it "should yield statements" do
+      @queryable.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
+        statement.should be_a_statement
+      end
     end
   end
 
   ##
   # @see RDF::Queryable#first
 
-  it "should support #first" do
-    @queryable.respond_to?(:first).should be_true
+  it "should respond to #first" do
+    @queryable.should respond_to(:first)
   end
 
   context "#first" do
@@ -119,8 +176,8 @@ share_as :RDF_Queryable do
   ##
   # @see RDF::Queryable#first_subject
 
-  it "should support #first_subject" do
-    @queryable.respond_to?(:first_subject).should be_true
+  it "should respond to #first_subject" do
+    @queryable.should respond_to(:first_subject)
   end
 
   context "#first_subject" do
@@ -154,8 +211,8 @@ share_as :RDF_Queryable do
   ##
   # @see RDF::Queryable#first_predicate
 
-  it "should support #first_predicate" do
-    @queryable.respond_to?(:first_predicate).should be_true
+  it "should respond to #first_predicate" do
+    @queryable.should respond_to(:first_predicate)
   end
 
   context "#first_predicate" do
@@ -189,8 +246,8 @@ share_as :RDF_Queryable do
   ##
   # @see RDF::Queryable#first_object
 
-  it "should support #first_object" do
-    @queryable.respond_to?(:first_object).should be_true
+  it "should respond to #first_object" do
+    @queryable.should respond_to(:first_object)
   end
 
   context "#first_object" do
@@ -224,8 +281,8 @@ share_as :RDF_Queryable do
   ##
   # @see RDF::Queryable#first_literal
 
-  it "should support #first_literal" do
-    @queryable.respond_to?(:first_literal).should be_true
+  it "should respond to #first_literal" do
+    @queryable.should respond_to(:first_literal)
   end
 
   context "#first_literal" do
@@ -266,8 +323,8 @@ share_as :RDF_Queryable do
   ##
   # @see RDF::Queryable#first_value
 
-  it "should support #first_value" do
-    @queryable.respond_to?(:first_value).should be_true
+  it "should respond to #first_value" do
+    @queryable.should respond_to(:first_value)
   end
 
   context "#first_value" do