rdf-spec 1.1.13 → 1.99.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53805ce5de30f3b9a172c530b8085c6171b559f3
-  data.tar.gz: 18b110beea3b90a51a7bfb8054c3bdace1614ceb
+  metadata.gz: 1f20ea6160511bc458dbf138ed1fe61d828f1d40
+  data.tar.gz: 03830cb0bc7e6322ed30a39a9938a64be387728c
 SHA512:
-  metadata.gz: 227cb6a7a6073e11f4886d7997a61173f796dbbed68458b0a2a4d217fedfb5fb239a669dfb7900c53a2ca3dea7659d82a7ab6a6c3edea2f0df75887873f5599e
-  data.tar.gz: 64dfe87b381a0b023f37d83722ab852d892e543b0207e4a630f3e1f81b9fe5754525715ec23b6b9f6ec9faa1508e04d31479aef75e851564f6eb76d286f37e45
+  metadata.gz: bd8eb7f3e272f487d4f1114a4df4cc68b061e81f36cb4b3355578d6b254ce92efa1f1e8304aae27191c35383221212f430e95cb2c747b285273c85331fc0be92
+  data.tar.gz: 83afd3996484fcec39368ece2024c2ba15f04ec6bcb213ddd59f817816eead5fe124493b54c2d52b22dd4c481598d6f7f78de7c204d661cae53b286365c58e13

data/VERSION

@@ -1 +1 @@
-1.1.13
+1.99.0

data/lib/rdf/spec.rb

@@ -1,5 +1,6 @@
 require 'rdf'   # @see http://rubygems.org/gems/rdf
 require 'rspec' # @see http://rubygems.org/gems/rspec
+require 'rdf/spec/inspects'
 require 'rspec/its'
 
 module RDF

data/lib/rdf/spec/countable.rb

@@ -24,22 +24,22 @@ RSpec.shared_examples 'an RDF::Countable' do
   describe RDF::Countable do
     subject {countable}
 
-    it {should respond_to(:empty?)}
-    it {should_not be_empty}
-    it {should respond_to(:count)}
-    its(:count) {should == @statements.size}
-    it {should respond_to(:size)}
-    its(:size) {should == @statements.size}
+    it {is_expected.to respond_to(:empty?)}
+    it {is_expected.to_not be_empty}
+    it {is_expected.to respond_to(:count)}
+    its(:count) {is_expected.to eq @statements.size}
+    it {is_expected.to respond_to(:size)}
+    its(:size) {is_expected.to eq @statements.size}
 
     context "when empty" do
       subject {[].extend(RDF::Countable)}
-      it {should be_empty}
-      its(:count) {should == 0}
-      its(:size) {should == 0}
+      it {is_expected.to be_empty}
+      its(:count) {is_expected.to eq 0}
+      its(:size) {is_expected.to eq 0}
     end
 
-    its(:to_enum) {should be_countable}
-    its(:enum_for) {should be_countable}
+    its(:to_enum) {is_expected.to be_countable}
+    its(:enum_for) {is_expected.to be_countable}
     it "#enum_for(:each)" do
       expect(subject.enum_for(:each)).to be_countable
     end

data/lib/rdf/spec/durable.rb

@@ -27,21 +27,21 @@ RSpec.shared_examples 'an RDF::Durable' do
 
   subject {@load_durable.call}
 
-  it { should respond_to(:durable?) }
+  it { is_expected.to respond_to(:durable?) }
 
-  it "should support #durable?" do
+  it "is_expected.to support #durable?" do
     expect([true,false]).to be_member(subject.durable?)
   end
 
-  it {should respond_to(:nondurable?)}
+  it {is_expected.to respond_to(:nondurable?)}
 
-  it "should support #nondurable?" do
+  it "is_expected.to support #nondurable?" do
     expect([true,false]).to be_member(@load_durable.call.nondurable?)
   end
 
-  its(:nondurable?) {should_not == subject.durable?}
+  its(:nondurable?) {is_expected.to_not eq subject.durable?}
 
-  it "should save contents between instantiations" do
+  it "is_expected.to save contents between instantiations" do
     if subject.durable?
       subject.load(RDF::Spec::TRIPLES_FILE)
       expect(subject.count).to eq File.readlines(RDF::Spec::TRIPLES_FILE).size

data/lib/rdf/spec/enumerable.rb

@@ -19,7 +19,7 @@ RSpec.shared_examples 'an RDF::Enumerable' do
       end
     end
 
-    @supports_context = enumerable.supports?(:context) rescue true
+    @supports_named_graphs = enumerable.supports?(:graph_name) rescue true
   end
 
   let(:subject_count) {@statements.map(&:subject).uniq.length}
@@ -27,12 +27,12 @@ RSpec.shared_examples 'an RDF::Enumerable' do
   let(:non_bnode_statements) {@statements.reject {|s| s.subject.node? || s.object.node?}}
 
   subject { enumerable }
-  it {should respond_to(:supports?)}
+  it {is_expected.to respond_to(:supports?)}
 
   describe "valid?" do
     it "reports validity" do
       if subject.supports?(:validity)
-        should be_valid
+        is_expected.to be_valid
       else
         expect {subject.valid?}.to raise_error(NotImplementedError)
       end
@@ -40,131 +40,127 @@ RSpec.shared_examples 'an RDF::Enumerable' do
 
     it "returns false if any statement is invalid" do
       if subject.respond_to?(:<<) && (subject.writable? rescue true)
-        s = RDF::Statement.from([nil, nil, nil])
+        s = RDF::Statement(RDF::URI("http://rubygems.org/gems/rdf"), RDF::Literal("literal"), RDF::URI("http://ar.to/#self"))
         if subject.supports?(:validity)
           expect(s).not_to  be_valid
           subject << s
-          expect(subject).not_to  be_valid
+          is_expected.not_to  be_valid
         else
           expect {subject.valid?}.to raise_error(NotImplementedError)
         end
-      else
-        skip("can't add statement to immutable enumerable")
       end
     end
   end
 
   context "when counting statements" do
-    it {should respond_to(:empty?)}
-    it {should_not be_empty}
-    it {should respond_to(:count)}
-    its(:count) {should == @statements.size}
-    it {should respond_to(:size)}
-    its(:size) {should == @statements.size}
+    it {is_expected.to respond_to(:empty?)}
+    it {is_expected.to_not be_empty}
+    it {is_expected.to respond_to(:count)}
+    its(:count) {is_expected.to eq @statements.size}
+    it {is_expected.to respond_to(:size)}
+    its(:size) {is_expected.to eq @statements.size}
 
     context "and empty" do
       subject {[].extend(RDF::Enumerable)}
-      it {should be_empty}
-      its(:count) {should == 0}
-      its(:size) {should == 0}
+      it {is_expected.to be_empty}
+      its(:count) {is_expected.to eq 0}
+      its(:size) {is_expected.to eq 0}
     end
   end
 
   context "when enumerating statements" do
-    it {should respond_to(:statements)}
-    its(:statements) {should be_an_enumerator}
+    it {is_expected.to respond_to(:statements)}
+    #its(:statements) {is_expected.to be_an_enumerator}
 
     context "#statements" do
       specify {expect(subject.statements.to_a.size).to eq @statements.size}
-      specify {subject.statements.each { |statement| expect(statement).to be_a_statement }}
+      specify {expect(subject.statements).to all(be_a_statement)}
     end
 
-    it {should respond_to(:has_statement?)}
+    it {is_expected.to respond_to(:has_statement?)}
     context "#has_statement?" do
       let(:unknown_statement) {RDF::Statement.new(RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new)}
       it "should have all statements" do
         # Don't check for BNodes, as equivalence depends on their being exactly the same, not just the same identifier. If subject is loaded separately, these won't match.
         non_bnode_statements.each do |statement|
-          expect(subject).to have_statement(statement)
+          is_expected.to have_statement(statement)
         end
       end
 
-      it "does not have statement in different context" do
-        if @supports_context
-          context = RDF::URI.new("urn:context:1")
+      it "does not have statement in different named graph" do
+        if @supports_named_graphs
+          graph_name = RDF::URI.new("urn:graph_name:1")
           non_bnode_statements.each do |statement|
             s = statement.dup
-            s.context = context
-            expect(subject).not_to have_statement(s)
+            s.graph_name = graph_name
+            is_expected.not_to have_statement(s)
           end
         end
       end
 
       it "does not have an unknown statement" do
-        expect(subject).not_to have_statement(unknown_statement)
+        is_expected.not_to have_statement(unknown_statement)
       end
     end
 
-    it {should respond_to(:each_statement)}
-    its(:each_statement) {should be_an_enumerator}
-    it "should implement #each_statement" do
-      subject.each_statement { |statement| expect(statement).to be_a_statement }
-    end
+    it {is_expected.to respond_to(:each_statement)}
+    its(:each_statement) {is_expected.to be_an_enumerator}
+    its(:each_statement) {expect(subject.each_statement).to all(be_a_statement)}
 
-    it {should respond_to(:enum_statement)}
-    its(:enum_statement) {should be_an_enumerator}
-    its(:enum_statement) {should be_countable}
-    its(:enum_statement) {should be_enumerable}
-    its(:enum_statement) {should be_queryable}
+    it {is_expected.to respond_to(:enum_statement)}
+    its(:enum_statement) {is_expected.to be_an_enumerator}
+    its(:enum_statement) {is_expected.to be_countable}
+    its(:enum_statement) {is_expected.to be_enumerable}
+    its(:enum_statement) {is_expected.to be_queryable}
     context "#enum_statement" do
       it "should enumerate all statements" do
         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?
+          expect(enumerable.each_statement.to_a).to include(s) unless s.node?
         end
       end
     end
   end
 
   context "when enumerating triples" do
-    it {should respond_to(:triples)}
-    it {should respond_to(:has_triple?)}
-    it {should respond_to(:each_triple)}
-    it {should respond_to(:enum_triple)}
+    it {is_expected.to respond_to(:triples)}
+    it {is_expected.to respond_to(:has_triple?)}
+    it {is_expected.to respond_to(:each_triple)}
+    it {is_expected.to respond_to(:enum_triple)}
 
-    its(:triples) {should be_an_enumerator}
+    #its(:triples) {is_expected.to be_an_enumerator}
     context "#triples" do
       specify {expect(subject.triples.to_a.size).to eq @statements.size}
-      specify {subject.triples.each { |triple| expect(triple).to be_a_triple }}
+      specify {expect(subject.triples).to all(be_a_triple)}
     end
 
     context "#has_triple?" do
       specify do
         non_bnode_statements.each do |statement|
-          expect(subject).to have_triple(statement.to_triple)
+          is_expected.to have_triple(statement.to_triple)
         end
       end
     end
 
-    its(:each_triple) {should be_an_enumerator}
+    its(:each_triple) {is_expected.to be_an_enumerator}
     context "#each_triple" do
-      specify {subject.each_triple { |*triple| expect(triple).to be_a_triple }}
+      specify {expect(subject.each_triple).to all(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(triple.each).to all(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}
+    its(:enum_triple) {is_expected.to be_an_enumerator}
+    its(:enum_triple) {is_expected.to be_countable}
     context "#enum_triple" do
       it "should enumerate all triples" do
         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([s, p, o]).to all(be_a_term)
           expect(enumerable).to have_triple([s, p, o]) unless [s, p, o].any?(&:node?)
         end
       end
@@ -172,45 +168,45 @@ RSpec.shared_examples 'an RDF::Enumerable' do
   end
 
   context "when enumerating quads" do
-    it {should respond_to(:quads)}
-    it {should respond_to(:has_quad?)}
-    it {should respond_to(:each_quad)}
-    it {should respond_to(:enum_quad)}
+    it {is_expected.to respond_to(:quads)}
+    it {is_expected.to respond_to(:has_quad?)}
+    it {is_expected.to respond_to(:each_quad)}
+    it {is_expected.to respond_to(:enum_quad)}
 
-    its(:quads) {should be_an_enumerator}
+    #its(:quads) {is_expected.to be_an_enumerator}
     context "#quads" do
       specify {expect(subject.quads.to_a.size).to eq @statements.size}
-      specify {subject.quads.each { |quad| expect(quad).to be_a_quad }}
+      specify {expect(subject.quads).to all(be_a_quad)}
     end
 
     context "#has_quad?" do
       specify do
-        if @supports_context
+        if @supports_named_graphs
           non_bnode_statements.each do |statement|
-            expect(subject).to have_quad(statement.to_quad)
+            is_expected.to have_quad(statement.to_quad)
           end
         end
       end
     end
 
-    its(:each_quad) {should be_an_enumerator}
+    its(:each_quad) {is_expected.to be_an_enumerator}
     context "#each_quad" do
-      specify {subject.each_quad {|*quad| expect(quad).to be_a_quad }}
+      specify {expect(subject.each_quad).to all(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(quad.compact).to all(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}
+    its(:enum_quad) {is_expected.to be_an_enumerator}
+    its(:enum_quad) {is_expected.to be_countable}
     context "#enum_quad" do
       it "should enumerate all quads" do
         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([s, p, o, c].compact).to all(be_a_term)
           expect(enumerable).to have_quad([s, p, o, c]) unless [s, p, o].any?(&:node?)
         end
       end
@@ -219,20 +215,20 @@ RSpec.shared_examples 'an RDF::Enumerable' do
 
   context "when enumerating subjects" do
     let(:subjects) {subject.map { |s| s.subject }.reject(&:node?).uniq}
-    it {should respond_to(:subjects)}
-    it {should respond_to(:has_subject?)}
-    it {should respond_to(:each_subject)}
-    it {should respond_to(:enum_subject)}
+    it {is_expected.to respond_to(:subjects)}
+    it {is_expected.to respond_to(:has_subject?)}
+    it {is_expected.to respond_to(:each_subject)}
+    it {is_expected.to respond_to(:enum_subject)}
 
-    its(:subjects) {should be_an_enumerator}
+    #its(:subjects) {is_expected.to be_an_enumerator}
     context "#subjects" do
       subject { enumerable.subjects }
-      specify {expect(subject).to be_an_enumerator}
-      specify {subject.each { |value| expect(value).to be_a_resource }}
-      context ":unique => false" do
-        subject { enumerable.subjects(:unique => false) }
-        specify {expect(subject).to be_an_enumerator}
-        specify {subject.each { |value| expect(value).to be_a_resource }}
+      specify {is_expected.to be_an_enumerator}
+      specify {is_expected.to all(be_a_resource)}
+      context "unique: false" do
+        subject { enumerable.subjects(unique: false) }
+        specify {is_expected.to be_an_enumerator}
+        specify {is_expected.to all(be_a_resource)}
       end
     end
 
@@ -248,15 +244,15 @@ RSpec.shared_examples 'an RDF::Enumerable' do
       end
     end
 
-    its(:each_subject) {should be_an_enumerator}
+    its(:each_subject) {is_expected.to be_an_enumerator}
     context "#each_subject" do
       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 {expect(subject.each_subject).to all(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}
+    its(:enum_subject) {is_expected.to be_an_enumerator}
+    its(:enum_subject) {is_expected.to 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
@@ -270,20 +266,20 @@ RSpec.shared_examples 'an RDF::Enumerable' do
 
   context "when enumerating predicates" do
     let(:predicates) {@statements.map { |s| s.predicate }.uniq}
-    it {should respond_to(:predicates)}
-    it {should respond_to(:has_predicate?)}
-    it {should respond_to(:each_predicate)}
-    it {should respond_to(:enum_predicate)}
+    it {is_expected.to respond_to(:predicates)}
+    it {is_expected.to respond_to(:has_predicate?)}
+    it {is_expected.to respond_to(:each_predicate)}
+    it {is_expected.to respond_to(:enum_predicate)}
 
-    its(:predicates) {should be_an_enumerator}
+    #its(:predicates) {is_expected.to be_an_enumerator}
     context "#predicates" do
       subject { enumerable.predicates }
-      specify {expect(subject).to be_an_enumerator}
-      specify {subject.each { |value| expect(value).to be_a_uri }}
-      context ":unique => false" do
-        subject { enumerable.predicates(:unique => false) }
-        specify {expect(subject).to be_an_enumerator}
-        specify {subject.each { |value| expect(value).to be_a_uri }}
+      specify {is_expected.to be_an_enumerator}
+      specify {is_expected.to all(be_a_uri)}
+      context "unique: false" do
+        subject { enumerable.predicates(unique: false) }
+        specify {is_expected.to be_an_enumerator}
+        specify {is_expected.to all(be_a_uri)}
       end
     end
 
@@ -299,15 +295,15 @@ RSpec.shared_examples 'an RDF::Enumerable' do
       end
     end
 
-    its(:each_predicate) {should be_an_enumerator}
+    its(:each_predicate) {is_expected.to be_an_enumerator}
     context "#each_predicate" do
       specify {expect(subject.each_predicate.to_a.size).to eq predicates.size}
-      specify {subject.each_predicate {|value| expect(value).to be_a_uri}}
+      specify {expect(subject.each_predicate).to all(be_a_uri)}
       specify {subject.each_predicate {|value| expect(predicates).to include(value)}}
     end
 
-    its(:enum_predicate) {should be_an_enumerator}
-    its(:enum_predicate) {should be_countable}
+    its(:enum_predicate) {is_expected.to be_an_enumerator}
+    its(:enum_predicate) {is_expected.to be_countable}
     context "#enum_predicate" do
       it "should enumerate all predicates" do
         expect(subject.enum_predicate.to_a).to include(*predicates)
@@ -317,20 +313,20 @@ RSpec.shared_examples 'an RDF::Enumerable' do
 
   context "when enumerating objects" do
     let(:objects) {subject.map(&:object).reject(&:node?).uniq}
-    it {should respond_to(:objects)}
-    it {should respond_to(:has_object?)}
-    it {should respond_to(:each_object)}
-    it {should respond_to(:enum_object)}
+    it {is_expected.to respond_to(:objects)}
+    it {is_expected.to respond_to(:has_object?)}
+    it {is_expected.to respond_to(:each_object)}
+    it {is_expected.to respond_to(:enum_object)}
 
-    its(:objects) {should be_an_enumerator}
+    #its(:objects) {is_expected.to be_an_enumerator}
     context "#objects" do
       subject { enumerable.objects }
-      specify {expect(subject).to be_an_enumerator}
-      specify {subject.each { |value| expect(value).to be_a_term }}
-      context ":unique => false" do
-        subject { enumerable.objects(:unique => false) }
-        specify {expect(subject).to be_an_enumerator}
-        specify {subject.each { |value| expect(value).to be_a_term }}
+      specify {is_expected.to be_an_enumerator}
+      specify {is_expected.to all(be_a_term)}
+      context "unique: false" do
+        subject { enumerable.objects(unique: false) }
+        specify {is_expected.to be_an_enumerator}
+        specify {is_expected.to all(be_a_term)}
       end
     end
 
@@ -346,15 +342,15 @@ RSpec.shared_examples 'an RDF::Enumerable' do
       end
     end
 
-    its(:each_object) {should be_an_enumerator}
+    its(:each_object) {is_expected.to be_an_enumerator}
     context "#each_object" do
       specify {expect(subject.each_object.reject(&:node?).size).to eq objects.size}
-      specify {subject.each_object {|value| expect(value).to be_a_term}}
+      specify {expect(subject.each_object).to all(be_a_term)}
       specify {subject.each_object {|value| expect(objects).to include(value) unless value.node?}}
     end
 
-    its(:enum_object) {should be_an_enumerator}
-    its(:enum_object) {should be_countable}
+    its(:enum_object) {is_expected.to be_an_enumerator}
+    its(:enum_object) {is_expected.to be_countable}
     context "#enum_object" do
       it "should enumerate all objects" do
         subject.enum_object.each do |o|
@@ -365,30 +361,26 @@ RSpec.shared_examples 'an RDF::Enumerable' do
     end
   end
 
-  context "when enumerating contexts" do
-    it {should respond_to(:contexts)}
-    it {should respond_to(:has_context?)}
-    it {should respond_to(:each_context)}
-    it {should respond_to(:enum_context)}
+  context "when enumerating contexts", unless: RDF::VERSION.to_s >= "1.99" do
+    it {is_expected.to respond_to(:contexts)}
+    it {is_expected.to respond_to(:has_context?)}
+    it {is_expected.to respond_to(:each_context)}
+    it {is_expected.to respond_to(:enum_context)}
 
-    its(:contexts) {should be_an_enumerator}
+    its(:contexts) {is_expected.to be_an_enumerator}
     describe "#contexts" do
       subject { enumerable.contexts }
-      specify {expect(subject).to be_an_enumerator}
-      it "values should be resources" do
-        subject.each { |value| expect(value).to be_a_resource }
-      end
-      context ":unique => false" do
-        subject { enumerable.contexts(:unique => false) }
-        specify {expect(subject).to be_an_enumerator}
-        it "values should be resources" do
-          subject.each { |value| expect(value).to be_a_resource }
-        end
+      specify {is_expected.to be_an_enumerator}
+      specify {is_expected.to all(be_a_resource)}
+      context "unique: false" do
+        subject { enumerable.contexts(unique: false) }
+        specify {is_expected.to be_an_enumerator}
+        specify {is_expected.to all(be_a_resource)}
       end
     end
 
-    it "should implement #has_context?" do
-      if @supports_context
+    it "is_expected.to implement #has_context?" do
+      if @supports_named_graphs
         @statements.each do |statement|
           if statement.has_context?
             expect(enumerable).to have_context(statement.context)
@@ -399,24 +391,22 @@ RSpec.shared_examples 'an RDF::Enumerable' do
       end
     end
 
-    its(:each_context) {should be_an_enumerator}
+    its(:each_context) {is_expected.to be_an_enumerator}
     context "#each_context" do
       let(:contexts) {@statements.map { |s| s.context }.uniq.compact}
       it "has appropriate number of contexts" do
-        if @supports_context
+        if @supports_named_graphs
           expect(subject.each_context.to_a.size).to eq contexts.size
         end
       end
-      it "values should be resources" do
-        subject.each_context {|value| expect(value).to be_a_resource}
-      end
-      it "should have all contexts" do
+      specify {expect(subject.each_context).to all(be_a_resource)}
+      it "is_expected.to have all contexts" do
         subject.each_context {|value| expect(contexts).to include(value)}
       end
     end
 
-    its(:enum_context) {should be_an_enumerator}
-    its(:enum_context) {should be_countable}
+    its(:enum_context) {is_expected.to be_an_enumerator}
+    its(:enum_context) {is_expected.to be_countable}
     context "#enum_context" do
       it "should enumerate all contexts" do
         expect(subject.enum_context.to_a).to include(*enumerable.each_context.to_a)
@@ -425,30 +415,62 @@ RSpec.shared_examples 'an RDF::Enumerable' do
   end
 
   context "when enumerating graphs" do
-    it {should respond_to(:each_graph)}
-    it {should respond_to(:enum_graph)}
+    it {is_expected.to respond_to(:each_graph)}
+    it {is_expected.to respond_to(:enum_graph)}
 
     describe "#each_graph" do
       subject { enumerable.each_graph }
-      it {should be_an_enumerator}
-      it "are all graphs" do
-        subject.each { |value| expect(value).to be_a_graph } if @supports_context
-      end
+      it {is_expected.to be_an_enumerator}
+      specify {is_expected.to all(be_a_graph)} if @supports_named_graphs
+      specify {expect(subject.each_graph).to all(be_a_graph)}
+
+      it "has appropriate number of graphs" do
+        graph_names = @statements.map { |s| s.graph_name }.uniq.compact
+        expect(subject.each_graph.to_a.size).to eq (graph_names.size + 1)
+      end if @supports_named_graphs
     end
 
     describe "#enum_graph" do
       subject { enumerable.enum_graph }
-      it {should be_an_enumerator}
-      it {should be_countable}
+      it {is_expected.to be_an_enumerator}
+      it {is_expected.to be_countable}
       it "enumerates the same as #each_graph" do
-        expect(subject.to_a).to include(*enumerable.each_graph.to_a) if @supports_context # expect with match problematic
+        expect(subject.to_a).to include(*enumerable.each_graph.to_a) if @supports_named_graphs # expect with match problematic
+      end
+    end
+  end
+
+  context "when enumerating graphs", if: RDF::VERSION.to_s >= "1.99" do
+    it {is_expected.to respond_to(:graph_names)}
+    it {is_expected.to respond_to(:has_graph?)}
+
+    describe "#graph_names" do
+      subject { enumerable.graph_names }
+      specify {is_expected.to be_a(Array)}
+      specify {is_expected.to all(be_a_resource)}
+      context "unique: false" do
+        subject { enumerable.graph_names(unique: false) }
+        specify {is_expected.to be_a(Array)}
+        specify {is_expected.to all(be_a_resource)}
+      end
+    end
+
+    describe "#has_graph?" do
+      if @supports_named_graphs
+        @statements.each do |statement|
+          if statement.has_graph?
+            expect(enumerable).to have_graph(statement.graph_name)
+          end
+        end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        expect(enumerable).not_to have_graph(uri)
       end
     end
   end
 
   context "when converting" do
-    it {should respond_to(:to_hash)}
-    its(:to_hash) {should be_instance_of(Hash)}
+    it {is_expected.to respond_to(:to_hash)}
+    its(:to_hash) {is_expected.to be_instance_of(Hash)}
     context "#to_hash" do
       it "should have as many keys as subjects" do
         expect(subject.to_hash.keys.size).to eq enumerable.subjects.to_a.size
@@ -457,7 +479,7 @@ RSpec.shared_examples 'an RDF::Enumerable' do
   end
 
   context "when dumping" do
-    it {should respond_to(:dump)}
+    it {is_expected.to respond_to(:dump)}
 
     it "should implement #dump" do
       expect(subject.dump(:ntriples)).to eq RDF::NTriples::Writer.buffer() {|w| w << enumerable}