Merge branch 'origin/1.1'

Author: gkellogg

.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.date               = File.mtime('VERSION').strftime('%Y-%m-%d')
 
   gem.name               = 'rdf-spec'
-  gem.homepage           = 'http://github.com/ruby-rdf/rdf-spec/'
+  gem.homepage           = 'http://ruby-rdf.github.com/rdf-spec/'
   gem.license            = 'Public Domain' if gem.respond_to?(:license=)
   gem.summary            = 'RSpec extensions for RDF.rb.'
   gem.description        = 'RDF.rb plugin that provides RSpec matchers and shared examples for RDF objects.'
@@ -25,9 +25,9 @@ Gem::Specification.new do |gem|
   gem.test_files         = %w()
   gem.has_rdoc           = false
 
-  gem.required_ruby_version      = '>= 1.8.7'
+  gem.required_ruby_version      = '>= 1.9.2'
   gem.requirements               = []
-  gem.add_development_dependency 'rdf',   '~> 1.0'
+  gem.add_development_dependency 'rdf',   '~> 1.1'
   gem.add_runtime_dependency     'rspec', '>= 2.14'
   gem.add_development_dependency 'yard' , '>= 0.8'
   gem.post_install_message       = nil

Gemfile

@@ -2,7 +2,7 @@ source "http://rubygems.org"
 
 gemspec :name => ""
 
-gem "rdf", :git => "git://github.com/ruby-rdf/rdf.git"
+gem "rdf", :git => "git://github.com/ruby-rdf/rdf.git", :branch => "develop"
 
 group :development do
   gem "wirble"

README.md

@@ -5,6 +5,8 @@ and shared examples for Ruby projects that use RDF.rb and RSpec.
 
 * <http://github.com/ruby-rdf/rdf-spec>
 
+[![Gem Version](https://badge.fury.io/rb/rdf-spec.png)](http://badge.fury.io/rb/rdf-spec)
+
 ## Documentation
 
 * {RDF::Spec}

VERSION

@@ -1 +1 @@
-1.0.9
+1.1.0

lib/rdf/spec/enumerable.rb

@@ -389,15 +389,17 @@ module RDF_Enumerable
       describe "#each_graph" do
         subject {@enumerable.each_graph}
         it {should be_an_enumerator}
-        specify {subject.each { |value| expect(value).to be_a_graph }}
+        it "are all graphs" do
+          subject.each { |value| expect(value).to be_a_graph } if @supports_context
+        end
       end
 
       describe "#enum_graph" do
         subject {@enumerable.enum_graph}
         it {should be_an_enumerator}
         it {should be_countable}
         it "enumerates the same as #each_graph" do
-          subject.to_a.should =~ @enumerable.each_graph.to_a # expect with match problematic
+          subject.to_a.should =~ @enumerable.each_graph.to_a if @supports_context # expect with match problematic
         end
       end
     end

lib/rdf/spec/matchers.rb

@@ -22,7 +22,7 @@ module Matchers
 
     RSpec::Matchers.define :be_an_enumerator do
       match do |enumerator|
-        expect(enumerator).to be_a_kind_of(RDF::Enumerator)
+        expect(enumerator).to be_a_kind_of(Enumerator)
         true
       end
     end

lib/rdf/spec/transaction.rb

@@ -1,62 +1,110 @@
 require 'rdf/spec'
 
-module RDF_Transaction
-  extend RSpec::SharedContext
+# Pass in an instance of RDF::Transaction as follows:
+#
+#   it_behaves_like "RDF_Transaction", RDF::Transaction
+shared_examples "RDF_Transaction" do |klass|
   include RDF::Spec::Matchers
 
-  before :each do
-    raise '+@transaction+ must be defined in a before(:each) block' unless instance_variable_get('@transaction')
-  end
-
   describe RDF::Transaction do
-    #TODO
+    subject {klass.new(:context => RDF::URI("name"), :insert => RDF::Graph.new, :delete => RDF::Graph.new)}
+
     describe "#initialize" do
-      it "accepts a graph"
-      it "accepts a context"
-      it "accepts inserts"
-      it "accepts deletes"
-    end
-  
-    describe "#graph" do
-      it "is mutable"
+      subject {klass}
+      it "accepts a graph" do
+        g = double("graph")
+        this = subject.new(:graph => g)
+        expect(this.graph).to eq g
+      end
+
+      it "accepts a context" do
+        c = double("context")
+        this = subject.new(:graph => c)
+        expect(this.graph).to eq c
+        expect(this.context).to eq c
+
+        this = subject.new(:context => c)
+        expect(this.graph).to eq c
+        expect(this.context).to eq c
+      end
+
+      it "accepts inserts" do
+        g = double("inserts")
+        this = subject.new(:insert => g)
+        expect(this.inserts).to eq g
+      end
+
+      it "accepts deletes" do
+        g = double("deletes")
+        this = subject.new(:delete => g)
+        expect(this.deletes).to eq g
+      end
     end
-  
-    describe "#deletes" do
-      it "is mutable"
+
+    its(:deletes) {should be_a(RDF::Enumerable)}
+    its(:inserts) {should be_a(RDF::Enumerable)}
+    it {should be_mutable}
+    it {should_not be_readable}
+
+    it "does not respond to #load" do
+      expect {subject.load("http://example/")}.to raise_error(NoMethodError)
     end
-  
-    describe "#inserts" do
-      it "is mutable"
+
+    it "does not respond to #update" do
+      expect {subject.update(RDF::Statement.new)}.to raise_error(NoMethodError)
     end
-  
-    describe "#readable?" do
-      it "returns false" do
-        expect(@transaction.readable?).to be_false
-      end
+
+    it "does not respond to #clear" do
+      expect {subject.clear}.to raise_error(NoMethodError)
     end
-  
+
     describe "#execute" do
-      it "deletes statements"
-      it "inserts statements"
-      it "calls before_execute"
-      it "calls after_execute"
-      it "returns self"
-      it "does not delete statements on failures"
-      it "does not insert statements on failures"
+      let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
+      let(:r) {double("repository")}
+
+      it "deletes statements" do
+        expect(r).to receive(:delete).with(s)
+        expect(r).not_to receive(:insert)
+        subject.delete(s)
+        subject.execute(r)
+      end
+
+      it "inserts statements" do
+        expect(r).not_to receive(:delete)
+        expect(r).to receive(:insert).with(s)
+        subject.insert(s)
+        subject.execute(r)
+      end
+
+      it "calls before_execute" do
+        expect(subject).to receive(:before_execute).with(r, {})
+        subject.execute(r)
+      end
+
+      it "calls after_execute" do
+        expect(subject).to receive(:after_execute).with(r, {})
+        subject.execute(r)
+      end
+
+      it "returns self" do
+        expect(subject.execute(r)).to eq subject
+      end
     end
 
     describe "#delete_statement" do
-      it "adds statement to #deletes"
-      it "does not remove statement from graph"
+      let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
+      it "adds statement to #deletes" do
+        subject.delete(s)
+        expect(subject.deletes.to_a).to eq [s]
+      end
     end
 
     describe "#insert_statement" do
-      it "adds statement to #inserts"
-      it "does not add statement to graph"
+      let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
+      it "adds statement to #inserts" do
+        subject.insert(s)
+        expect(subject.inserts.to_a).to eq [s]
+      end
     end
-  
-    it "does not respond to #load"
-    it "does not respond to #update"
-    it "does not respond to #clear"
   end
 end