rdf-spec 0.1.4 → 0.1.6

data/README

@@ -15,7 +15,7 @@ Documentation
 Dependencies
 ------------
 
-* [RDF.rb](http://gemcutter.org/gems/rdf) (>= 0.1.4)
+* [RDF.rb](http://gemcutter.org/gems/rdf) (>= 0.1.6)
 * [RSpec](http://gemcutter.org/gems/rspec) (>= 1.3.0)
 
 Installation

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.6

data/lib/rdf/spec/enumerable.rb

@@ -40,7 +40,8 @@ share_as :RDF_Enumerable do
         @enumerable.has_statement?(statement).should be_true
       end
 
-      @enumerable.has_statement?([RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new]).should be_false
+      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 support #each_statement" do
@@ -130,16 +131,25 @@ share_as :RDF_Enumerable do
     it "should support #has_subject?" do
       @enumerable.respond_to?(:has_subject?).should be_true
 
+      checked = []
       @statements.each do |statement|
-        @enumerable.has_subject?(statement.subject).should be_true
+        @enumerable.has_subject?(statement.subject).should be_true 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
     end
 
     it "should support #each_subject" do
       @enumerable.respond_to?(:each_subject).should be_true
 
       @enumerable.each_subject.should be_instance_of(Enumerable::Enumerator)
-      @enumerable.each_subject { |value| value.should be_a_resource }
+      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
+      end
     end
 
     it "should support #enum_subject" do
@@ -160,16 +170,25 @@ share_as :RDF_Enumerable do
     it "should support #has_predicate?" do
       @enumerable.respond_to?(:has_predicate?).should be_true
 
+      checked = []
       @statements.each do |statement|
-        @enumerable.has_predicate?(statement.predicate).should be_true
+        @enumerable.has_predicate?(statement.predicate).should be_true unless checked.include?(statement.object)
+        checked << statement.predicate
       end
+      uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+      @enumerable.has_predicate?(uri).should be_false
     end
 
     it "should support #each_predicate" do
       @enumerable.respond_to?(:each_predicate).should be_true
 
+      predicates = @statements.map { |s| s.predicate }.uniq
+      @enumerable.each_predicate.to_a.size.should == predicates.size
       @enumerable.each_predicate.should be_instance_of(Enumerable::Enumerator)
-      @enumerable.each_predicate { |value| value.should be_a_uri }
+      @enumerable.each_predicate do |value| 
+        value.should be_a_uri
+        predicates.should include value
+      end
     end
 
     it "should support #enum_predicate" do
@@ -190,16 +209,25 @@ share_as :RDF_Enumerable do
     it "should support #has_object?" do
       @enumerable.respond_to?(:has_object?).should be_true
 
+      checked = []
       @statements.each do |statement|
-        @enumerable.has_object?(statement.object).should be_true
+        @enumerable.has_object?(statement.object).should be_true 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
     end
 
     it "should support #each_object" do
       @enumerable.respond_to?(:each_object).should be_true
 
+      objects = @statements.map { |s| s.object }.uniq
+      @enumerable.each_object.to_a.size.should == objects.size
       @enumerable.each_object.should be_instance_of(Enumerable::Enumerator)
-      @enumerable.each_object { |value| value.should be_a_value }
+      @enumerable.each_object do |value| 
+        value.should be_a_value
+        objects.should include value
+      end
     end
 
     it "should support #enum_object" do
@@ -225,13 +253,21 @@ share_as :RDF_Enumerable do
           @enumerable.has_context?(statement.context).should be_true
         end
       end
+      uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+      @enumerable.has_context?(uri).should be_false
     end
 
     it "should support #each_context" do
       @enumerable.respond_to?(:each_context).should be_true
 
+      contexts = @statements.map { |s| s.context }.uniq
+      contexts.delete nil
+      @enumerable.each_context.to_a.size.should == contexts.size
       @enumerable.each_context.should be_instance_of(Enumerable::Enumerator)
-      @enumerable.each_context { |value| value.should be_a_resource }
+      @enumerable.each_context do |value| 
+        value.should be_a_resource 
+        contexts.should include value
+      end
     end
 
     it "should support #enum_context" do

data/lib/rdf/spec/graph.rb

@@ -0,0 +1,46 @@
+require 'rdf'
+require 'rdf/spec'
+
+share_as :RDF_Graph do
+
+  before :each do
+    raise '+@new+ must be defined in a before(:each) block' unless instance_variable_get('@new')
+  end
+
+  context "unnamed graphs" do
+    it "should be instantiable" do
+      lambda { @new.call }.should_not raise_error
+    end
+
+    it "should be unnamed" do
+      graph = @new.call
+      graph.unnamed?.should be_true
+      graph.named?.should be_false
+    end
+
+    it "should not have a context" do
+      graph = @new.call
+      graph.context.should be_nil
+      graph.contexts.size.should == 0
+    end
+  end
+
+  context "named graphs" do
+    it "should be instantiable" do
+      lambda { @new.call }.should_not raise_error
+    end
+
+    it "should be named" do
+      graph = @new.call("http://rdf.rubyforge.org/")
+      graph.unnamed?.should be_false
+      graph.named?.should be_true
+    end
+
+    it "should have a context" do
+      graph = @new.call("http://rdf.rubyforge.org/")
+      graph.context.should_not be_nil
+      graph.contexts.size.should == 1
+    end
+  end
+
+end

data/lib/rdf/spec/literal.rb

@@ -0,0 +1,160 @@
+require 'rdf'
+require 'rdf/spec'
+
+share_as :RDF_Literal do
+
+  XSD = RDF::XSD
+
+  before :each do
+    raise '+@new+ must be defined in a before(:each) block' unless instance_variable_get('@new')
+  end
+
+  context "plain literals" do
+    before :each do
+      @empty = @new.call('')
+      @hello = @new.call('Hello')
+      @all   = [@empty, @hello]
+    end
+
+    it "should be instantiable" do
+      lambda { @new.call('') }.should_not raise_error
+      @all.each do |literal|
+        literal.plain?.should be_true
+      end
+    end
+
+    it "should not have a language" do
+      @all.each do |literal|
+        literal.language.should be_nil
+      end
+    end
+
+    it "should not have a datatype" do
+      @all.each do |literal|
+        literal.typed?.should be_false
+        literal.datatype.should be_nil
+      end
+    end
+
+    it "should support equality comparisons" do
+      @all.each do |literal|
+        copy = @new.call(literal.value)
+        literal.should eql(copy)
+        literal.should == copy
+
+        literal.should_not eql(literal.value)
+        literal.should == literal.value # FIXME
+      end
+    end
+
+    it "should have a string representation" do
+      @empty.to_s.should eql('""')
+      @hello.to_s.should eql('"Hello"')
+    end
+  end
+
+  context "languaged-tagged literals" do
+    before :each do
+      @empty = @new.call('', :language => :en)
+      @hello = @new.call('Hello', :language => :en)
+      @all   = [@empty, @hello]
+    end
+
+    it "should be instantiable" do
+      lambda { @new.call('', :language => :en) }.should_not raise_error
+    end
+
+    it "should have a language" do
+      @all.each do |literal|
+        literal.language.should_not be_nil
+        literal.language.should == :en
+      end
+    end
+
+    it "should not have a datatype" do
+      @all.each do |literal|
+        literal.typed?.should be_false
+        literal.datatype.should be_nil
+      end
+    end
+
+    it "should support equality comparisons" do
+      @all.each do |literal|
+        copy = @new.call(literal.value, :language => literal.language)
+        literal.should eql(copy)
+        literal.should == copy
+      end
+    end
+
+    it "should have a string representation" do
+      @empty.to_s.should eql('""@en')
+      @hello.to_s.should eql('"Hello"@en')
+    end
+  end
+
+  context "datatyped literals" do
+    require 'date'
+
+    before :each do
+      @string   = @new.call('')
+      @false    = @new.call(false)
+      @true     = @new.call(true)
+      @int      = @new.call(123)
+      @long     = @new.call(9223372036854775807)
+      @double   = @new.call(3.1415)
+      @time     = @new.call(Time.now)
+      @date     = @new.call(Date.new(2010))
+      @datetime = @new.call(DateTime.new(2010))
+      @all      = [@false, @true, @int, @long, @double, @time, @date, @datetime]
+    end
+
+    it "should be instantiable" do
+      lambda { @new.call(123) }.should_not raise_error
+      lambda { @new.call(123, :datatype => XSD.int) }.should_not raise_error
+    end
+
+    it "should not have a language" do
+      @all.each do |literal|
+        literal.language.should be_nil
+      end
+    end
+
+    it "should have a datatype" do
+      @all.each do |literal|
+        literal.typed?.should be_true
+        literal.datatype.should_not be_nil
+      end
+    end
+
+    it "should support implicit datatyping" do
+      @string.datatype.should == nil
+      @false.datatype.should == XSD.boolean
+      @true.datatype.should == XSD.boolean
+      @int.datatype.should == XSD.integer
+      @long.datatype.should == XSD.integer
+      @double.datatype.should == XSD.double
+      @time.datatype.should == XSD.dateTime
+      @date.datatype.should == XSD.date
+      @datetime.datatype.should == XSD.dateTime
+    end
+
+    it "should support equality comparisons" do
+      @all.each do |literal|
+        copy = @new.call(literal.value, :datatype => literal.datatype)
+        literal.should eql(copy)
+        literal.should == copy
+      end
+    end
+
+    it "should have a string representation" do
+      @false.to_s.should eql('"false"^^<http://www.w3.org/2001/XMLSchema#boolean>')
+      @true.to_s.should eql('"true"^^<http://www.w3.org/2001/XMLSchema#boolean>')
+      @int.to_s.should eql('"123"^^<http://www.w3.org/2001/XMLSchema#integer>')
+      @long.to_s.should eql('"9223372036854775807"^^<http://www.w3.org/2001/XMLSchema#integer>')
+      @double.to_s.should eql('"3.1415"^^<http://www.w3.org/2001/XMLSchema#double>')
+      @date.to_s.should eql('"2010-01-01"^^<http://www.w3.org/2001/XMLSchema#date>')
+      @datetime.to_s.should eql('"2010-01-01T00:00:00+00:00"^^<http://www.w3.org/2001/XMLSchema#dateTime>') # FIXME
+    end
+  end
+
+end

data/lib/rdf/spec/mutable.rb

@@ -59,11 +59,9 @@ share_as :RDF_Mutable do
       @repository.should have_context @context
       @repository.query(:context => @context).size.should == @repository.size
     end
-
   end
 
   context "when inserting statements" do
-
     before :each do
       @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
     end
@@ -98,7 +96,6 @@ share_as :RDF_Mutable do
   end
 
   context "when deleting statements" do
-
     before :each do
       @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
       @repository.insert(*@statements)
@@ -122,6 +119,18 @@ share_as :RDF_Mutable do
       @statements.find { |s| @repository.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
+
+      # everything deleted
+      @repository.delete([nil, nil, nil])
+      @repository.should be_empty
+    end
   end
 
   context "when clearing all statements" do

data/lib/rdf/spec/node.rb

@@ -0,0 +1,14 @@
+require 'rdf'
+require 'rdf/spec'
+
+share_as :RDF_Node do
+
+  before :each do
+    raise '+@new+ must be defined in a before(:each) block' unless instance_variable_get('@new')
+  end
+
+ 
+  it "should be instantiable" do
+    lambda { @new.call }.should_not raise_error
+  end
+end

data/lib/rdf/spec/statement.rb

@@ -0,0 +1,172 @@
+require 'rdf/spec'
+require 'spec'
+
+share_as :RDF_Statement do
+  include RDF::Spec::Matchers
+
+  before :each do
+    raise '+@n3+ must be defined in a before(:each) block' unless instance_variable_get('@n3')
+    raise '+@s+ must be defined in a before(:each) block' unless instance_variable_get('@s')
+    raise '+@p+ must be defined in a before(:each) block' unless instance_variable_get('@p')
+    raise '+@o+ must be defined in a before(:each) block' unless instance_variable_get('@o')
+    raise '+@stmt+ must be defined in a before(:each) block' unless instance_variable_get('@stmt')
+  end
+
+  context "when initializing" do
+    it "should be instantiable with a hash argument" do
+      lambda { RDF::Statement.new(:subject => @s,
+                                  :predicate => @p,
+                                  :object => @o) }.should_not raise_error(ArgumentError)
+
+    end
+
+    it "should not alter a hash argument" do
+      hash = { :subject => @s, :predicate => @p, :object => @o }
+      original_hash = hash.dup
+      stmt = RDF::Statement.new(hash)
+      original_hash.should == hash
+    end
+
+    it "should not alter its options argument" do
+      options = { :context => RDF::DOAP.name }
+      original_options = options.dup
+      stmt = RDF::Statement.new(@s, @p, @o, options)
+      options.should == original_options
+    end
+  end
+
+  context "when created" do
+    it "should not require arguments" do
+      lambda { RDF::Statement.new }.should_not raise_error(ArgumentError)
+    end
+
+    it "should have a subject" do
+      @stmt.has_subject?.should be_true
+      @stmt.subject.should_not be_nil
+    end
+
+    it "should have a predicate" do
+      @stmt.has_predicate?.should be_true
+      @stmt.predicate.should_not be_nil
+    end
+
+    it "should have an object" do
+      @stmt.has_object?.should be_true
+      @stmt.object.should_not be_nil
+    end
+
+    it "should be asserted" do
+      @stmt.asserted?.should be_true
+    end
+
+    it "should not be quoted" do
+      @stmt.quoted?.should be_false
+    end
+  end
+
+  context "when created with a blank node subject" do
+    before :each do
+      @stmt = RDF::Statement.new(RDF::Node.new, @p, @o)
+    end
+
+    it "should have a blank node" do
+      @stmt.has_blank_nodes?.should be_true
+    end
+  end
+
+  context "when created with a blank node object" do
+    before :each do
+      @stmt = RDF::Statement.new(@s, @p, RDF::Node.new)
+    end
+
+    it "should have a blank node" do
+      @stmt.has_blank_nodes?.should be_true
+    end
+  end
+
+  context "when created without a context" do
+    it "should not have a context" do
+      @stmt = RDF::Statement.new(@s, @p, @o, :context => nil)
+      @stmt.context.should be_nil
+      @stmt.has_context?.should be_false
+    end
+  end
+
+  context "when created with a context" do
+    it "should have a context" do
+      @stmt = RDF::Statement.new(@s, @p, @o, :context => @s)
+      @stmt.has_context?.should be_true
+      @stmt.context.should_not be_nil
+    end
+  end
+
+  context "when used like an Array" do
+    it "should support #to_a" do
+      @stmt.should respond_to(:to_a)
+      @stmt.to_a.should eql([@stmt.subject, @stmt.predicate, @stmt.object])
+    end
+
+    it "should support #[]" do
+      @stmt.should respond_to(:[])
+      @stmt[0].should equal(@stmt.subject)
+      @stmt[1].should equal(@stmt.predicate)
+      @stmt[2].should equal(@stmt.object)
+    end
+
+    it "should support #[]=" do
+      @stmt.should respond_to(:[]=)
+      # TODO
+    end
+  end
+
+  context "when used like a Hash" do
+    it "should support #to_hash" do
+      @stmt.should respond_to(:to_hash)
+      @stmt.to_hash.should eql({
+        :subject   => @stmt.subject,
+        :predicate => @stmt.predicate,
+        :object    => @stmt.object,
+      })
+    end
+  end
+
+  context "when used like a String" do
+    it "should support #to_s" do
+      @stmt.should respond_to(:to_s)
+    end
+
+    it "should have an N-Triples representation" do
+      @stmt.to_s.should eql(@n3)
+    end
+  end
+
+  context "when comparing equality" do
+    before :each do
+      @c = RDF::URI.parse("http://example.org/context")
+      @other_stmt = RDF::Statement.new(@s, @p, @o, :context => @c)
+    end
+
+    it "should == regardless of context" do
+      @stmt.should == @other_stmt
+    end
+
+    it "should not be eql? with differing contexts" do
+      @stmt.should_not be_eql @other_stmt
+    end
+
+    it "should match (===) a statement with a missing component to one with that component" do
+      @stmt.should === @other_stmt
+    end
+
+    it "should not match (===) a statement with a component to one which is missing that component" do
+      @other_stmt.should_not === @stmt
+    end
+
+    it "should only equals? with object equality" do
+      @same_stmt = RDF::Statement.new @s, @p, @o
+      @stmt.should_not equal @same_stmt
+      @stmt.should equal @stmt
+    end
+
+  end
+end

data/lib/rdf/spec/uri.rb

@@ -0,0 +1,49 @@
+require 'rdf'
+require 'rdf/spec'
+
+share_as :RDF_URI do
+
+  before :each do
+    raise '+@new+ must be defined in a before(:each) block' unless instance_variable_get('@new')
+  end
+
+  it "should be instantiable" do
+    lambda { @new.call("http://rdf.rubyforge.org/") }.should_not raise_error
+  end
+
+  it "should return the root URI" do
+    uri = @new.call("http://rdf.rubyforge.org/RDF/URI.html")
+    uri.should respond_to(:root)
+    uri.root.should be_a_uri
+    uri.root.should == @new.call("http://rdf.rubyforge.org/")
+  end
+
+  it "should find the parent URI" do
+    uri = @new.call("http://rdf.rubyforge.org/RDF/URI.html")
+    uri.should respond_to(:parent)
+    uri.parent.should be_a_uri
+    uri.parent.should == @new.call("http://rdf.rubyforge.org/RDF/")
+    uri.parent.parent.should == @new.call("http://rdf.rubyforge.org/")
+    uri.parent.parent.parent.should be_nil
+  end
+
+  it "should return a consistent hash code" do
+    hash1 = @new.call("http://rdf.rubyforge.org/").hash
+    hash2 = @new.call("http://rdf.rubyforge.org/").hash
+    hash1.should == hash2
+  end
+
+  it "should be duplicable" do
+    url  = Addressable::URI.parse("http://rdf.rubyforge.org/")
+    uri2 = (uri1 = @new.call(url)).dup
+
+    uri1.should_not be_equal(uri2)
+    uri1.should be_eql(uri2)
+    uri1.should == uri2
+
+    url.path = '/rdf/'
+    uri1.should_not be_equal(uri2)
+    uri1.should_not be_eql(uri2)
+    uri1.should_not == uri2
+  end
+end

data/lib/rdf/spec/value.rb

@@ -0,0 +1,30 @@
+require 'rdf'
+require 'rdf/spec'
+
+share_as :RDF_Value do
+
+  before :each do
+    raise '+@value+ must be defined in a before(:each) block' unless instance_variable_get('@value')
+    raise '+@resource+ must be defined in a before(:each) block' unless instance_variable_get('@resource')
+  end
+
+  describe RDF::Value do
+    it "should not be instantiable" do
+      lambda { @value.call }.should raise_error(NoMethodError)
+    end
+  end
+
+  describe RDF::Resource do
+    it "should instantiate blank nodes" do
+      resource = @resource.call('_:foobar')
+      resource.class.should == RDF::Node
+      resource.id.should == 'foobar'
+    end
+
+    it "should instantiate URIs" do
+      resource = @resource.call('http://rdf.rubyforge.org/')
+      resource.class.should == RDF::URI
+      resource.to_s.should == 'http://rdf.rubyforge.org/'
+    end
+  end
+end

data/lib/rdf/spec/version.rb

@@ -2,7 +2,7 @@ module RDF; module Spec
   module VERSION
     MAJOR = 0
     MINOR = 1
-    TINY  = 4
+    TINY  = 6
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY].join('.')

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 4
-  version: 0.1.4
+  - 6
+  version: 0.1.6
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-03 00:00:00 +02:00
+date: 2010-04-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,8 +28,8 @@ dependencies:
         segments: 
         - 0
         - 1
-        - 4
-        version: 0.1.4
+        - 6
+        version: 0.1.6
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -90,10 +90,16 @@ files:
 - etc/doap.nt
 - lib/rdf/spec/durable.rb
 - lib/rdf/spec/enumerable.rb
+- lib/rdf/spec/graph.rb
+- lib/rdf/spec/literal.rb
 - lib/rdf/spec/matchers.rb
 - lib/rdf/spec/mutable.rb
+- lib/rdf/spec/node.rb
 - lib/rdf/spec/queryable.rb
 - lib/rdf/spec/repository.rb
+- lib/rdf/spec/statement.rb
+- lib/rdf/spec/uri.rb
+- lib/rdf/spec/value.rb
 - lib/rdf/spec/version.rb
 - lib/rdf/spec.rb
 - spec/enumerable_spec.rb