Fix Enumerable.enum_triple and enum_quad which were broken.

Author: gkellogg

lib/rdf/spec/enumerable.rb

@@ -117,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
@@ -145,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
@@ -181,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
@@ -225,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
@@ -328,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

lib/rdf/spec/matchers.rb

@@ -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)