rdf 0.0.7 → 0.0.8

data/lib/rdf/spec.rb

@@ -0,0 +1,138 @@
+require 'spec'
+
+module RDF
+  ##
+  # RDF extensions for RSpec.
+  #
+  # @see http://rspec.info/
+  module Spec
+    ##
+    # RDF matchers for RSpec.
+    #
+    # @see http://rspec.rubyforge.org/rspec/1.2.9/classes/Spec/Matchers.html
+    module Matchers
+      ##
+      # Defines a new RSpec matcher.
+      #
+      # @param  [Symbol] name
+      # @return [void]
+      def self.define(name, &declarations)
+        define_method name do |*expected|
+          ::Spec::Matchers::Matcher.new(name, *expected, &declarations)
+        end
+      end
+
+      define :be_a_statement do
+        match do |statement|
+          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
+          true
+        end
+      end
+
+      define :be_a_triple do
+        match do |triple|
+          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) unless triple[2].is_a?(String) # FIXME
+          true
+        end
+      end
+
+      define :be_a_quad do
+        match do |quad|
+          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) unless quad[2].is_a?(String) # FIXME
+          quad[3].should be_a_kind_of(RDF::Resource) unless quad[3].nil?
+          true
+        end
+      end
+
+      define :be_a_resource do
+        match do |value|
+          value.should be_a_kind_of(RDF::Resource)
+          true
+        end
+      end
+
+      define :be_a_uri do
+        match do |value|
+          value.should be_a_kind_of(RDF::URI)
+          true
+        end
+      end
+
+      define :be_a_value do
+        match do |value|
+          value.should be_a_kind_of(RDF::Value) unless value.is_a?(String) # FIXME
+          true
+        end
+      end
+
+      define :be_a_vocabulary do |base_uri|
+        match do |vocabulary|
+          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
+
+      define :have_properties do |base_uri, properties|
+        match do |vocabulary|
+          properties.map(&: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
+            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
+      end
+
+      define :have_subclasses do |base_uri, klasses|
+        match do |vocabulary|
+          klasses.map(&:to_sym).each do |klass|
+            # TODO
+          end
+          true
+        end
+      end
+
+      define :be_a_repository do
+        match do |repository|
+          repository.should be_a_kind_of(RDF::Repository)
+          true
+        end
+      end
+
+      define :be_a_repository_of_size do |size|
+        match do |repository|
+          repository.should be_a_repository
+          repository.size == size
+        end
+      end
+
+      define :have_predicate do |predicate, count|
+        match do |queryable|
+          if count.nil?
+            queryable.has_predicate?(predicate)
+          else
+            queryable.query([nil, predicate, nil]).size == count
+          end
+        end
+      end
+    end # module Matchers
+  end # module Spec
+end # module RDF

data/lib/rdf/spec/enumerable.rb

@@ -0,0 +1,248 @@
+require 'rdf/spec'
+
+share_as :RDF_Enumerable do
+  include RDF::Spec::Matchers
+
+  before :each do
+    raise '+@enumerable+ must be defined in a before(:each) block' unless instance_variable_get('@enumerable')
+    raise '+@statements+ must be defined in a before(:each) block' unless instance_variable_get('@statements')
+  end
+
+  it "should support #empty?" do
+    @enumerable.respond_to?(:empty?).should be_true
+
+    ([].extend(RDF::Enumerable)).empty?.should be_true
+    @enumerable.empty?.should be_false
+  end
+
+  it "should support #count and #size" do
+    [:count, :size, :length].each do |method|
+      @enumerable.respond_to?(method).should be_true
+
+      @enumerable.send(method).should == @statements.size
+    end
+  end
+
+  context "statements" do
+    it "should support #statements" do
+      @enumerable.respond_to?(:statements).should be_true
+
+      @enumerable.statements.should be_instance_of(Array)
+      @enumerable.statements.size.should == @statements.size
+      @enumerable.statements.each { |statement| statement.should be_a_statement }
+    end
+
+    it "should support #has_statement?" do
+      @enumerable.respond_to?(:has_statement?).should be_true
+
+      @statements.each do |statement|
+        @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
+    end
+
+    it "should support #each_statement" do
+      @enumerable.respond_to?(:each_statement).should be_true
+
+      @enumerable.each_statement.should be_instance_of(Enumerable::Enumerator)
+      @enumerable.each_statement { |statement| statement.should be_a_statement }
+    end
+
+    it "should support #enum_statement" do
+      @enumerable.respond_to?(:enum_statement).should be_true
+
+      @enumerable.enum_statement.should be_instance_of(Enumerable::Enumerator)
+    end
+  end
+
+  context "triples" do
+    it "should support #triples" do
+      @enumerable.respond_to?(:triples).should be_true
+
+      @enumerable.triples.should be_instance_of(Array)
+      @enumerable.triples.size.should == @statements.size
+      @enumerable.triples.each { |triple| triple.should be_a_triple }
+    end
+
+    it "should support #has_triple?" do
+      @enumerable.respond_to?(:has_triple?).should be_true
+
+      @statements.each do |statement|
+        @enumerable.has_triple?(statement.to_triple).should be_true
+      end
+    end
+
+    it "should support #each_triple" do
+      @enumerable.respond_to?(:each_triple).should be_true
+
+      @enumerable.each_triple.should be_instance_of(Enumerable::Enumerator)
+      @enumerable.each_triple { |*triple| triple.should be_a_triple }
+    end
+
+    it "should support #enum_triple" do
+      @enumerable.respond_to?(:enum_triple).should be_true
+
+      @enumerable.enum_triple.should be_instance_of(Enumerable::Enumerator)
+    end
+  end
+
+  context "quads" do
+    it "should support #quads" do
+      @enumerable.respond_to?(:quads).should be_true
+
+      @enumerable.quads.should be_instance_of(Array)
+      @enumerable.quads.size.should == @statements.size
+      @enumerable.quads.each { |quad| quad.should be_a_quad }
+    end
+
+    it "should support #has_quad?" do
+      @enumerable.respond_to?(:has_quad?).should be_true
+
+      @statements.each do |statement|
+        @enumerable.has_quad?(statement.to_quad).should be_true
+      end
+    end
+
+    it "should support #each_quad" do
+      @enumerable.respond_to?(:each_quad).should be_true
+
+      @enumerable.each_quad.should be_instance_of(Enumerable::Enumerator)
+      @enumerable.each_quad { |*quad| quad.should be_a_quad }
+    end
+
+    it "should support #enum_quad" do
+      @enumerable.respond_to?(:enum_quad).should be_true
+
+      @enumerable.enum_quad.should be_instance_of(Enumerable::Enumerator)
+    end
+  end
+
+  context "subjects" do
+    it "should support #subjects" do
+      @enumerable.respond_to?(:subjects).should be_true
+
+      @enumerable.subjects.should be_instance_of(Array)
+      @enumerable.subjects.each { |value| value.should be_a_resource }
+    end
+
+    it "should support #has_subject?" do
+      @enumerable.respond_to?(:has_subject?).should be_true
+
+      @statements.each do |statement|
+        @enumerable.has_subject?(statement.subject).should be_true
+      end
+    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 }
+    end
+
+    it "should support #enum_subject" do
+      @enumerable.respond_to?(:enum_subject).should be_true
+
+      @enumerable.enum_subject.should be_instance_of(Enumerable::Enumerator)
+    end
+  end
+
+  context "predicates" do
+    it "should support #predicates" do
+      @enumerable.respond_to?(:predicates).should be_true
+
+      @enumerable.predicates.should be_instance_of(Array)
+      @enumerable.predicates.each { |value| value.should be_a_uri }
+    end
+
+    it "should support #has_predicate?" do
+      @enumerable.respond_to?(:has_predicate?).should be_true
+
+      @statements.each do |statement|
+        @enumerable.has_predicate?(statement.predicate).should be_true
+      end
+    end
+
+    it "should support #each_predicate" do
+      @enumerable.respond_to?(:each_predicate).should be_true
+
+      @enumerable.each_predicate.should be_instance_of(Enumerable::Enumerator)
+      @enumerable.each_predicate { |value| value.should be_a_uri }
+    end
+
+    it "should support #enum_predicate" do
+      @enumerable.respond_to?(:enum_predicate).should be_true
+
+      @enumerable.enum_predicate.should be_instance_of(Enumerable::Enumerator)
+    end
+  end
+
+  context "objects" do
+    it "should support #objects" do
+      @enumerable.respond_to?(:objects).should be_true
+
+      @enumerable.objects.should be_instance_of(Array)
+      @enumerable.objects.each { |value| value.should be_a_value }
+    end
+
+    it "should support #has_object?" do
+      @enumerable.respond_to?(:has_object?).should be_true
+
+      @statements.each do |statement|
+        @enumerable.has_object?(statement.object).should be_true
+      end
+    end
+
+    it "should support #each_object" do
+      @enumerable.respond_to?(:each_object).should be_true
+
+      @enumerable.each_object.should be_instance_of(Enumerable::Enumerator)
+      @enumerable.each_object { |value| value.should be_a_value }
+    end
+
+    it "should support #enum_object" do
+      @enumerable.respond_to?(:enum_object).should be_true
+
+      @enumerable.enum_object.should be_instance_of(Enumerable::Enumerator)
+    end
+  end
+
+  context "contexts" do
+    it "should support #contexts" do
+      @enumerable.respond_to?(:contexts).should be_true
+
+      @enumerable.contexts.should be_instance_of(Array)
+      @enumerable.contexts.each { |value| value.should be_a_resource }
+    end
+
+    it "should support #has_context?" do
+      @enumerable.respond_to?(:has_context?).should be_true
+
+      @statements.each do |statement|
+        if statement.has_context?
+          @enumerable.has_context?(statement.context).should be_true
+        end
+      end
+    end
+
+    it "should support #each_context" do
+      @enumerable.respond_to?(:each_context).should be_true
+
+      @enumerable.each_context.should be_instance_of(Enumerable::Enumerator)
+      @enumerable.each_context { |value| value.should be_a_resource }
+    end
+
+    it "should support #enum_context" do
+      @enumerable.respond_to?(:enum_context).should be_true
+
+      @enumerable.enum_context.should be_instance_of(Enumerable::Enumerator)
+    end
+  end
+
+  it "should support #to_hash" do
+    @enumerable.respond_to?(:to_hash).should be_true
+
+    # TODO
+  end
+end

data/lib/rdf/spec/repository.rb

@@ -0,0 +1,77 @@
+require 'rdf/spec'
+
+share_as :RDF_Repository do
+  include RDF::Spec::Matchers
+
+  before :each do
+    raise '+@repository+ must be defined in a before(:each) block' unless instance_variable_get('@repository')
+    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
+    @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+    @enumerable = @repository
+  end
+
+  it "should be empty initially" do
+    @repository.empty?.should be_true
+    @repository.count.should be_zero
+  end
+
+  it "should be readable" do
+    @repository.readable?.should be_true
+  end
+
+  it "should be mutable" do
+    @repository.immutable?.should be_false
+    @repository.mutable?.should be_true
+  end
+
+  context "when inserting statements" do
+    it "should support #insert" do
+      @repository.should respond_to(:insert)
+    end
+
+    it "should not raise errors" do
+      lambda { @repository.insert(@statements.first) }.should_not raise_error
+    end
+
+    it "should support inserting one statement at a time" do
+      @repository.insert(@statements.first)
+    end
+
+    it "should support inserting multiple statements at a time" do
+      @repository.insert(*@statements)
+    end
+
+    it "should insert statements successfully" do
+      @repository.insert(*@statements)
+      @repository.count.should == @statements.size
+    end
+  end
+
+  context "when deleting statements" do
+    it "should support #delete" do
+      @repository.should respond_to(:delete)
+    end
+
+    it "should not raise errors"
+    it "should support deleting one statement at a time"
+    it "should support deleting multiple statements at a time"
+    it "should delete statements successfully"
+  end
+
+  context "when clearing all statements" do
+    it "should support #clear" do
+      @repository.should respond_to(:clear)
+    end
+  end
+
+  context "when enumerating statements" do
+    require 'rdf/spec/enumerable'
+
+    before :each do
+      @repository.insert(*@statements)
+      @enumerable = @repository
+    end
+
+    it_should_behave_like RDF_Enumerable
+  end
+end