Finish 1.1.0

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

.gitignore

@@ -5,3 +5,4 @@ pkg
 tmp
 /*.gem
 /*.lock
+/doc/

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

@@ -29,14 +29,24 @@ module RDF_Enumerable
     it {should respond_to(:supports?)}
 
     describe "valid?" do
-      it {should be_valid}
+      it "reports validity" do
+        if subject.supports?(:validity)
+          should be_valid
+        else
+          expect {subject.valid?}.to raise_error(NotImplementedError)
+        end
+      end
 
       it "returns false if any statement is invalid" do
         if subject.respond_to?(:<<) && (subject.writable? rescue true)
           s = RDF::Statement.from([nil, nil, nil])
-          expect(s).not_to  be_valid
-          subject << s
-          expect(subject).not_to  be_valid
+          if subject.supports?(:validity)
+            expect(s).not_to  be_valid
+            subject << s
+            expect(subject).not_to  be_valid
+          else
+            expect {subject.valid?}.to raise_error(NotImplementedError)
+          end
         else
           pending("can't add statement to immutable enumerable")
         end
@@ -107,7 +117,11 @@ module RDF_Enumerable
       its(:enum_statement) {should be_queryable}
       context "#enum_statement" do
         it "should enumerate all statements" do
-          expect(subject.enum_statement.to_a).to include(*@enumerable.each_statement.to_a)
+          expect(subject.enum_statement.count).to eq @enumerable.each_statement.count
+          subject.enum_statement.each do |s|
+            expect(s).to be_a_statement
+            expect(@enumerable.each_statement.to_a).to include(s) unless s.has_blank_nodes?
+          end
         end
       end
     end
@@ -135,13 +149,23 @@ module RDF_Enumerable
       its(:each_triple) {should be_an_enumerator}
       context "#each_triple" do
         specify {subject.each_triple { |*triple| expect(triple).to be_a_triple }}
+        it "should iterate over all triples" do
+          subject.each_triple do |*triple|
+            triple.each {|r| expect(r).to be_a_term}
+            expect(@enumerable).to have_triple(triple) unless triple.any?(&:node?)
+          end
+        end
       end
 
       its(:enum_triple) {should be_an_enumerator}
       its(:enum_triple) {should be_countable}
       context "#enum_triple" do
         it "should enumerate all triples" do
-          expect(subject.enum_triple.to_a).to include(*@enumerable.each_triple.to_a)
+          expect(subject.enum_triple.count).to eq @enumerable.each_triple.count
+          subject.enum_triple.each do |s, p, o|
+            [s, p, o].each {|r| expect(r).to be_a_term}
+            expect(@enumerable).to have_triple([s, p, o]) unless [s, p, o].any?(&:node?)
+          end
         end
       end
     end
@@ -171,13 +195,23 @@ module RDF_Enumerable
       its(:each_quad) {should be_an_enumerator}
       context "#each_quad" do
         specify {subject.each_quad {|*quad| expect(quad).to be_a_quad }}
+        it "should iterate over all quads" do
+          subject.each_quad do |*quad|
+            quad.compact.each {|r| expect(r).to be_a_term}
+            expect(@enumerable).to have_quad(quad) unless quad.compact.any?(&:node?)
+          end
+        end
       end
 
       its(:enum_quad) {should be_an_enumerator}
       its(:enum_quad) {should be_countable}
       context "#enum_quad" do
         it "should enumerate all quads" do
-          expect(subject.enum_quad.to_a).to include(*@enumerable.each_quad.to_a)
+          expect(subject.enum_quad.count).to eq @enumerable.each_quad.count
+          subject.enum_quad.each do |s, p, o, c|
+            [s, p, o, c].compact.each {|r| expect(r).to be_a_term}
+            expect(@enumerable).to have_quad([s, p, o, c]) unless [s, p, o].any?(&:node?)
+          end
         end
       end
     end
@@ -215,16 +249,20 @@ module RDF_Enumerable
 
       its(:each_subject) {should be_an_enumerator}
       context "#each_subject" do
-        specify {expect(subject.each_subject.reject(&:node?).size).to eq subjects.size}
+        specify {expect(subject.each_subject.reject(&:node?).size).to eq subjects.reject(&:node?).size}
         specify {subject.each_subject {|value| expect(value).to be_a_resource}}
         specify {subject.each_subject {|value| expect(subjects).to include(value) unless value.node?}}
       end
 
       its(:enum_subject) {should be_an_enumerator}
       its(:enum_subject) {should be_countable}
       context "#enum_subject" do
+        specify {expect(subject.enum_subject.to_a.reject(&:node?).size).to eq subjects.reject(&:node?).size}
         it "should enumerate all subjects" do
-          expect(subject.enum_subject.reject(&:node?)).to include(*subjects)
+          subject.enum_subject.each do |s|
+            expect(s).to be_a_resource
+            expect(subjects.to_a).to include(s) unless s.node?
+          end
         end
       end
     end
@@ -318,7 +356,10 @@ module RDF_Enumerable
       its(:enum_object) {should be_countable}
       context "#enum_object" do
         it "should enumerate all objects" do
-          expect(subject.enum_object.reject(&:node?)).to include(*objects)
+          subject.enum_object.each do |o|
+            expect(o).to be_a_term
+            expect(objects.to_a).to include(o) unless o.node?
+          end
         end
       end
     end
@@ -389,15 +430,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
+        it "enumerates the same as #each_graph", :pending => "graph inclusion issue" do
+          expect(subject.to_a).to include(*@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
@@ -74,6 +74,13 @@ module Matchers
       end
     end
 
+    RSpec::Matchers.define :be_a_term do
+      match do |value|
+        expect(value).to be_a_kind_of(RDF::Term)
+        true
+      end
+    end
+
     RSpec::Matchers.define :be_a_resource do
       match do |value|
         expect(value).to be_a_kind_of(RDF::Resource)

lib/rdf/spec/queryable.rb

@@ -18,11 +18,11 @@ module RDF_Queryable
       end
     end
   end
-  let(:resource) {RDF::URI('http://rubygems.org/gems/rdf')}
-  let(:literal) {RDF::Literal.new('J. Random Hacker')}
 
   describe RDF::Queryable do
     subject {@queryable}
+    let(:resource) {RDF::URI('http://rubygems.org/gems/rdf')}
+    let(:literal) {RDF::Literal.new('J. Random Hacker')}
     let(:query) {RDF::Query.new {pattern [:s, :p, :o]}}
 
     ##
@@ -86,6 +86,7 @@ module RDF_Queryable
               subject.query([:s, :p, :o]) {}
             end
           end
+
           context "with a Query argument" do
             it "yields statements" do
               subject.query(query) do |solution|
@@ -103,49 +104,65 @@ module RDF_Queryable
         end
 
         context "without a block" do
-          it "returns an enumerator" do
-            expect(subject.query([nil, nil, nil])).to be_an_enumerator
-          end
+          context "with a triple argument" do
+            it "returns an enumerator" do
+              expect(subject.query([nil, nil, nil])).to be_an_enumerator
+            end
 
-          it "returns an enumerable enumerator" do
-            expect(subject.query([nil, nil, nil])).to be_enumerable
-          end
+            it "returns an enumerable enumerator" do
+              expect(subject.query([nil, nil, nil])).to be_enumerable
+            end
 
-          it "returns a queryable enumerator" do
-            expect(subject.query([nil, nil, nil])).to be_queryable
-          end
+            it "returns a queryable enumerator" do
+              expect(subject.query([nil, nil, nil])).to be_queryable
+            end
 
-          it "returns statements given a triple" do
-            subject.query([nil, nil, nil]).each do |statement|
-              expect(statement).to be_a_statement
-              expect(statement).not_to  be_a RDF::Query::Solution
+            it "returns statements given a triple" do
+              subject.query([nil, nil, nil]).each do |statement|
+                expect(statement).to be_a_statement
+                expect(statement).not_to  be_a RDF::Query::Solution
+              end
             end
           end
 
-          it "returns solutions given a query" do
-            subject.query(query).each do |solution|
-              expect(solution).not_to  be_a_statement
-              expect(solution).to be_a RDF::Query::Solution
+          context "with a Query argument" do
+            it "returns solutions" do
+              expect(subject.query(query)).to be_a(RDF::Query::Solutions)
             end
-          end
 
-          it "returns the correct number of results for array queries" do
-            expect(subject.query([nil, nil, nil]).size).to eq @statements.size
-            expect(subject.query([resource, nil, nil]).size).to eq File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
-            expect(subject.query([RDF::URI("http://ar.to/#self"), nil, nil]).size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
-            expect(subject.query([resource, RDF::DOAP.name, nil]).size).to eq 1
-            expect(subject.query([nil, nil, RDF::DOAP.Project]).size).to eq 1
-          end
+            it "does not return an enumerable enumerator" do
+              expect(subject.query(query)).not_to be_enumerable
+            end
 
-          it "returns the correct number of results for hash queries" do
-            expect(subject.query({}).size).to eq @statements.size
-            expect(subject.query(:subject => resource).size).to eq File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
-            expect(subject.query(:subject => resource, :predicate => RDF::DOAP.name).size).to eq 1
-            expect(subject.query(:object => RDF::DOAP.Project).size).to eq 1
-          end
+            it "does not return a queryable enumerator" do
+              expect(subject.query(query)).not_to be_queryable
+            end
 
-          it "returns the correct number of results for query queries" do
-            expect(subject.query(query).size).to eq @statements.size
+            it "returns solutions given a query" do
+              subject.query(query).each do |solution|
+                expect(solution).not_to  be_a_statement
+                expect(solution).to be_a RDF::Query::Solution
+              end
+            end
+
+            it "returns the correct number of results for array queries" do
+              expect(subject.query([nil, nil, nil]).size).to eq @statements.size
+              expect(subject.query([resource, nil, nil]).size).to eq File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
+              expect(subject.query([RDF::URI("http://ar.to/#self"), nil, nil]).size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
+              expect(subject.query([resource, RDF::DOAP.name, nil]).size).to eq 1
+              expect(subject.query([nil, nil, RDF::DOAP.Project]).size).to eq 1
+            end
+
+            it "returns the correct number of results for hash queries" do
+              expect(subject.query({}).size).to eq @statements.size
+              expect(subject.query(:subject => resource).size).to eq File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
+              expect(subject.query(:subject => resource, :predicate => RDF::DOAP.name).size).to eq 1
+              expect(subject.query(:object => RDF::DOAP.Project).size).to eq 1
+            end
+
+            it "returns the correct number of results for query queries" do
+              expect(subject.query(query).size).to eq @statements.size
+            end
           end
         end