rdf-spec 1.1.5 → 1.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd937b914454e1beb178c07aea7f67241ef6199a
-  data.tar.gz: 5025462c4843c791c182d73f82e7901dacd8cb24
+  metadata.gz: 53805ce5de30f3b9a172c530b8085c6171b559f3
+  data.tar.gz: 18b110beea3b90a51a7bfb8054c3bdace1614ceb
 SHA512:
-  metadata.gz: 673c8f7b7fa7e7666585833640e61787dcdb9f5edcdf98bc3947b54832aee0d58bc4bc60cfac23fae05ffb9e96a10cc343451cf823a2726d8481e0046f0f2ee0
-  data.tar.gz: d6ccea63ee7aa054de864c8535287e84ddb6cbb791d878c7d5a10e6381addf1c6377ce5a9455bf1968dbda0933a8ff8fdf226fa78cbe8ac35921448ce5ea0635
+  metadata.gz: 227cb6a7a6073e11f4886d7997a61173f796dbbed68458b0a2a4d217fedfb5fb239a669dfb7900c53a2ca3dea7659d82a7ab6a6c3edea2f0df75887873f5599e
+  data.tar.gz: 64dfe87b381a0b023f37d83722ab852d892e543b0207e4a630f3e1f81b9fe5754525715ec23b6b9f6ec9faa1508e04d31479aef75e851564f6eb76d286f37e45

data/CREDITS

@@ -1 +1,2 @@
 * John Fieber <jrf@ursamaris.org>
+* Tom Johnson <johnson.tom@gmail.com>

data/README

@@ -59,6 +59,7 @@ follows:
 ## Contributors
 
 * [John Fieber](http://github.com/jfieber) - <http://github.com/jfieber>
+* [Tom Johnson](https://github.com/no-reply) - <https://github.com/no-reply>
 
 ## Contributing
 

data/VERSION

@@ -1 +1 @@
-1.1.5
+1.1.13

data/lib/rdf/spec/countable.rb

@@ -1,27 +1,28 @@
 require 'rdf/spec'
 
-module RDF_Countable
-  extend RSpec::SharedContext
+RSpec.shared_examples 'an RDF::Countable' do
   include RDF::Spec::Matchers
 
-  before :each do
-    raise '+@countable+ must be defined in a before(:each) block' unless instance_variable_get('@countable')
+  before do
+    raise 'countable must be set with `let(:countable)' unless
+      defined? countable
 
     @statements = RDF::Spec.quads
 
-    if @countable.empty?
-      if (@countable.writable? rescue false)
-        @countable.insert_statements(@statements)
-      elsif @countable.respond_to?(:<<)
-        @statements.each { |statement| @countable << statement }
+    if countable.empty?
+      if (countable.writable? rescue false)
+        countable.send(:insert_statements, @statements)
+      elsif countable.respond_to?(:<<)
+        @statements.each { |statement| countable << statement }
       else
-        raise "+@countable+ must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
+        raise "+countable+ must respond to #<< or be pre-populated with the" \
+              "statements in #{RDF::Spec::TRIPLES_FILE} in a before block"
       end
     end
   end
 
   describe RDF::Countable do
-    subject {@countable}
+    subject {countable}
 
     it {should respond_to(:empty?)}
     it {should_not be_empty}
@@ -44,3 +45,25 @@ module RDF_Countable
     end
   end
 end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Countable"` instead
+module RDF_Countable
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Countable` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Countable'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Countable' do
+      let(:countable) { @countable }
+
+      before do
+        raise '@countable must be defined' unless defined?(countable)
+      end
+    end
+  end
+end

data/lib/rdf/spec/durable.rb

@@ -14,35 +14,53 @@ require 'rdf/spec'
 #      File.delete('test.db') if File.exists?('test.db')
 #    end
 #
-#    include RDF_Repository
+#    it_behaves_like 'an RDF::Repository'
 #  end
 #end
-module RDF_Durable
-  extend RSpec::SharedContext
+RSpec.shared_examples 'an RDF::Durable' do
   include RDF::Spec::Matchers
 
   before :each do
-    raise '+@load_durable+ must be defined in a before(:each) block' unless instance_variable_get('@load_durable')
+    raise '+@load_durable+ must be defined in a before(:each) block' unless
+      instance_variable_get('@load_durable')
   end
 
-  describe RDF::Durable do
-    subject {@load_durable.call}
-    it {should respond_to(:durable?)}
-    it "should support #durable?" do
-      expect([true,false]).to be_member(subject.durable?)
-    end
+  subject {@load_durable.call}
 
-    it {should respond_to(:nondurable?)}
-    it "should support #nondurable?" do
-      expect([true,false]).to be_member(@load_durable.call.nondurable?)
-    end
-    its(:nondurable?) {should_not == subject.durable?}
+  it { should respond_to(:durable?) }
+
+  it "should support #durable?" do
+    expect([true,false]).to be_member(subject.durable?)
+  end
+
+  it {should respond_to(:nondurable?)}
+
+  it "should support #nondurable?" do
+    expect([true,false]).to be_member(@load_durable.call.nondurable?)
+  end
+
+  its(:nondurable?) {should_not == subject.durable?}
 
-    it "should 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
-      end
+  it "should 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
     end
   end
 end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Durable"` instead
+module RDF_Durable
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Durable` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Durable'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Durable'
+  end
+end

data/lib/rdf/spec/enumerable.rb

@@ -1,471 +1,491 @@
 require 'rdf/spec'
 
-module RDF_Enumerable
-  extend RSpec::SharedContext
+RSpec.shared_examples 'an 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')
+  before do
+    raise 'enumerable must be set with `let(:enumerable)' unless
+      defined? enumerable
 
     @statements ||= RDF::Spec.quads
 
-    if @enumerable.empty?
-      if (@enumerable.writable? rescue false)
-        @enumerable.insert(*@statements)
-      elsif @enumerable.respond_to?(:<<)
-        @statements.each { |statement| @enumerable << statement }
+    if enumerable.empty?
+      if (enumerable.writable? rescue false)
+        enumerable.insert(*@statements)
+      elsif enumerable.respond_to?(:<<)
+        @statements.each { |statement| enumerable << statement }
       else
         raise "@enumerable must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
       end
     end
 
-    @supports_context = @enumerable.supports?(:context) rescue true
+    @supports_context = enumerable.supports?(:context) rescue true
   end
 
-  describe RDF::Enumerable do
-    let(:subject_count) {@statements.map(&:subject).uniq.length}
-    let(:bnode_subject_count) {@statements.map(&:subject).uniq.select(&:node?).length}
-    let(:non_bnode_statements) {@statements.reject {|s| s.subject.node? || s.object.node?}}
+  let(:subject_count) {@statements.map(&:subject).uniq.length}
+  let(:bnode_subject_count) {@statements.map(&:subject).uniq.select(&:node?).length}
+  let(:non_bnode_statements) {@statements.reject {|s| s.subject.node? || s.object.node?}}
 
-    subject {@enumerable}
-    it {should respond_to(:supports?)}
+  subject { enumerable }
+  it {should respond_to(:supports?)}
+
+  describe "valid?" do
+    it "reports validity" do
+      if subject.supports?(:validity)
+        should be_valid
+      else
+        expect {subject.valid?}.to raise_error(NotImplementedError)
+      end
+    end
 
-    describe "valid?" do
-      it "reports validity" 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])
         if subject.supports?(:validity)
-          should be_valid
+          expect(s).not_to  be_valid
+          subject << s
+          expect(subject).not_to  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])
-          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
+      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}
-
-      context "and empty" do
-        subject {[].extend(RDF::Enumerable)}
-        it {should be_empty}
-        its(:count) {should == 0}
-        its(:size) {should == 0}
-      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}
+
+    context "and empty" do
+      subject {[].extend(RDF::Enumerable)}
+      it {should be_empty}
+      its(:count) {should == 0}
+      its(:size) {should == 0}
     end
+  end
 
-    context "when enumerating statements" do
-      it {should respond_to(:statements)}
-      its(:statements) {should be_an_enumerator}
+  context "when enumerating statements" do
+    it {should respond_to(:statements)}
+    its(:statements) {should 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 }}
-      end
+    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 }}
+    end
 
-      it {should 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)
-          end
+    it {should 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)
         end
+      end
 
-        it "does not have statement in different context" do
-          if @supports_context
-            context = RDF::URI.new("urn:context:1")
-            non_bnode_statements.each do |statement|
-              s = statement.dup
-              s.context = context
-              expect(subject).not_to have_statement(s)
-            end
+      it "does not have statement in different context" do
+        if @supports_context
+          context = RDF::URI.new("urn:context:1")
+          non_bnode_statements.each do |statement|
+            s = statement.dup
+            s.context = context
+            expect(subject).not_to have_statement(s)
           end
         end
-
-        it "does not have an unknown statement" do
-          expect(subject).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 }
+      it "does not have an unknown statement" do
+        expect(subject).not_to have_statement(unknown_statement)
       end
+    end
 
-      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}
-      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?
-          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 {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}
+    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?
         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)}
+  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)}
 
-      its(:triples) {should 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 }}
-      end
+    its(:triples) {should 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 }}
+    end
 
-      context "#has_triple?" do
-        specify do
-          non_bnode_statements.each do |statement|
-            expect(subject).to have_triple(statement.to_triple)
-          end
+    context "#has_triple?" do
+      specify do
+        non_bnode_statements.each do |statement|
+          expect(subject).to have_triple(statement.to_triple)
         end
       end
+    end
 
-      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
+    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.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
+    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.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
 
-    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)}
+  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)}
 
-      its(:quads) {should 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 }}
-      end
+    its(:quads) {should 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 }}
+    end
 
-      context "#has_quad?" do
-        specify do
-          if @supports_context
-            non_bnode_statements.each do |statement|
-              expect(subject).to have_quad(statement.to_quad)
-            end
+    context "#has_quad?" do
+      specify do
+        if @supports_context
+          non_bnode_statements.each do |statement|
+            expect(subject).to have_quad(statement.to_quad)
           end
         end
       end
+    end
 
-      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
+    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.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
+    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.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
 
-    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)}
-
-      its(:subjects) {should be_an_enumerator}
-      context "#subjects" do
-        subject {@enumerable.subjects}
+  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)}
+
+    its(:subjects) {should 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 }}
-        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 }}
-        end
       end
+    end
 
-      context "#has_subject?" do
-        specify do
-          checked = []
-          non_bnode_statements.each do |statement|
-            expect(@enumerable).to have_subject(statement.subject) unless checked.include?(statement.subject)
-            checked << statement.subject
-          end
-          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-          expect(@enumerable).not_to have_subject(uri)
+    context "#has_subject?" do
+      specify do
+        checked = []
+        non_bnode_statements.each do |statement|
+          expect(enumerable).to have_subject(statement.subject) unless checked.include?(statement.subject)
+          checked << statement.subject
         end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        expect(enumerable).not_to have_subject(uri)
       end
+    end
 
-      its(:each_subject) {should 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 {subject.each_subject {|value| expect(subjects).to include(value) unless value.node?}}
-      end
+    its(:each_subject) {should 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 {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
-          subject.enum_subject.each do |s|
-            expect(s).to be_a_resource
-            expect(subjects.to_a).to include(s) unless s.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
+        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
 
-    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)}
-
-      its(:predicates) {should be_an_enumerator}
-      context "#predicates" do
-        subject {@enumerable.predicates}
+  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)}
+
+    its(:predicates) {should 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 }}
-        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 }}
-        end
       end
+    end
 
-      context "#has_predicate?" do
-        specify do
-          checked = []
-          @statements.each do |statement|
-            expect(@enumerable).to have_predicate(statement.predicate) unless checked.include?(statement.predicate)
-            checked << statement.predicate
-          end
-          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-          expect(@enumerable).not_to have_predicate(uri)
+    context "#has_predicate?" do
+      specify do
+        checked = []
+        @statements.each do |statement|
+          expect(enumerable).to have_predicate(statement.predicate) unless checked.include?(statement.predicate)
+          checked << statement.predicate
         end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        expect(enumerable).not_to have_predicate(uri)
       end
+    end
 
-      its(:each_predicate) {should 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 {subject.each_predicate {|value| expect(predicates).to include(value)}}
-      end
+    its(:each_predicate) {should 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 {subject.each_predicate {|value| expect(predicates).to include(value)}}
+    end
 
-      its(:enum_predicate) {should be_an_enumerator}
-      its(:enum_predicate) {should be_countable}
-      context "#enum_predicate" do
-        it "should enumerate all predicates" do
-          expect(subject.enum_predicate.to_a).to include(*predicates)
-        end
+    its(:enum_predicate) {should be_an_enumerator}
+    its(:enum_predicate) {should be_countable}
+    context "#enum_predicate" do
+      it "should enumerate all predicates" do
+        expect(subject.enum_predicate.to_a).to include(*predicates)
       end
     end
+  end
 
-    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)}
-
-      its(:objects) {should be_an_enumerator}
-      context "#objects" do
-        subject {@enumerable.objects}
+  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)}
+
+    its(:objects) {should 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 }}
-        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 }}
-        end
       end
+    end
 
-      context "#has_object?" do
-        specify do
-          checked = []
-          non_bnode_statements.each do |statement|
-            expect(@enumerable).to have_object(statement.object) unless checked.include?(statement.object)
-            checked << statement.object
-          end
-          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-          expect(@enumerable).not_to have_object(uri)
+    context "#has_object?" do
+      specify do
+        checked = []
+        non_bnode_statements.each do |statement|
+          expect(enumerable).to have_object(statement.object) unless checked.include?(statement.object)
+          checked << statement.object
         end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        expect(enumerable).not_to have_object(uri)
       end
+    end
 
-      its(:each_object) {should 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 {subject.each_object {|value| expect(objects).to include(value) unless value.node?}}
-      end
+    its(:each_object) {should 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 {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}
-      context "#enum_object" do
-        it "should enumerate all objects" do
-          subject.enum_object.each do |o|
-            expect(o).to be_a_term
-            expect(objects.to_a).to include(o) unless o.node?
-          end
+    its(:enum_object) {should be_an_enumerator}
+    its(:enum_object) {should be_countable}
+    context "#enum_object" do
+      it "should enumerate all objects" do
+        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
 
-    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)}
-
-      its(:contexts) {should be_an_enumerator}
-      describe "#contexts" do
-        subject {@enumerable.contexts}
+  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)}
+
+    its(:contexts) {should 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
-        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
-        end
       end
+    end
 
-      it "should implement #has_context?" do
-        if @supports_context
-          @statements.each do |statement|
-            if statement.has_context?
-              expect(@enumerable).to have_context(statement.context)
-            end
+    it "should implement #has_context?" do
+      if @supports_context
+        @statements.each do |statement|
+          if statement.has_context?
+            expect(enumerable).to have_context(statement.context)
           end
-          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-          expect(@enumerable).not_to have_context(uri)
         end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        expect(enumerable).not_to have_context(uri)
       end
+    end
 
-      its(:each_context) {should 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
-            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
-          subject.each_context {|value| expect(contexts).to include(value)}
+    its(:each_context) {should 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
+          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
+        subject.each_context {|value| expect(contexts).to include(value)}
+      end
+    end
 
-      its(:enum_context) {should be_an_enumerator}
-      its(:enum_context) {should 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)
-        end
+    its(:enum_context) {should be_an_enumerator}
+    its(:enum_context) {should 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)
       end
     end
+  end
 
-    context "when enumerating graphs" do
-      it {should respond_to(:each_graph)}
-      it {should respond_to(:enum_graph)}
+  context "when enumerating graphs" do
+    it {should respond_to(:each_graph)}
+    it {should 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
+    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
+    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
-          expect(subject.to_a).to include(*@enumerable.each_graph.to_a) if @supports_context # expect with match problematic
-        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
+        expect(subject.to_a).to include(*enumerable.each_graph.to_a) if @supports_context # expect with match problematic
       end
     end
+  end
 
-    context "when converting" do
-      it {should respond_to(:to_hash)}
-      its(:to_hash) {should 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
-        end
+  context "when converting" do
+    it {should respond_to(:to_hash)}
+    its(:to_hash) {should 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
       end
     end
-  
-    context "when dumping" do
-      it {should respond_to(:dump)}
-    
-      it "should implement #dump" do
-        expect(subject.dump(:ntriples)).to eq RDF::NTriples::Writer.buffer() {|w| w << @enumerable}
-      end
-    
-      it "raises error on unknown format" do
-        expect {subject.dump(:foobar)}.to raise_error(RDF::WriterError, /No writer found/)
+  end
+
+  context "when dumping" do
+    it {should respond_to(:dump)}
+
+    it "should implement #dump" do
+      expect(subject.dump(:ntriples)).to eq RDF::NTriples::Writer.buffer() {|w| w << enumerable}
+    end
+
+    it "raises error on unknown format" do
+      expect {subject.dump(:foobar)}.to raise_error(RDF::WriterError, /No writer found/)
+    end
+  end
+end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Enumerable"` instead
+module RDF_Enumerable
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Enumerable` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Enumerable'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Enumerable' do
+      let(:enumerable) { @enumerable }
+
+      before do
+        raise '@enumerable must be defined' unless defined?(enumerable)
       end
     end
   end