rdf-spec 1.1.5 → 1.1.13

data/lib/rdf/spec/transaction.rb

@@ -2,109 +2,111 @@ require 'rdf/spec'
 
 # Pass in an instance of RDF::Transaction as follows:
 #
-#   it_behaves_like "RDF_Transaction", RDF::Transaction
-shared_examples "RDF_Transaction" do |klass|
+#   it_behaves_like "RDF::Transaction", RDF::Transaction
+shared_examples "an RDF::Transaction" do |klass|
   include RDF::Spec::Matchers
 
-  describe RDF::Transaction do
-    subject {klass.new(:context => RDF::URI("name"), :insert => RDF::Graph.new, :delete => RDF::Graph.new)}
-
-    describe "#initialize" do
-      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
+  subject {klass.new(:context => RDF::URI("name"), :insert => RDF::Graph.new, :delete => RDF::Graph.new)}
+
+  describe "#initialize" do
+    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
 
-    its(:deletes) {should be_a(RDF::Enumerable)}
-    its(:inserts) {should be_a(RDF::Enumerable)}
-    it {should be_mutable}
-    it {should_not be_readable}
+    it "accepts deletes" do
+      g = double("deletes")
+      this = subject.new(:delete => g)
+      expect(this.deletes).to eq g
+    end
+  end
+
+  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
+
+  it "does not respond to #update" do
+    expect {subject.update(RDF::Statement.new)}.to raise_error(NoMethodError)
+  end
+
+  it "does not respond to #clear" do
+    expect {subject.clear}.to raise_error(NoMethodError)
+  end
+
+  describe "#execute" do
+    let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
+    let(:r) {double("repository")}
 
-    it "does not respond to #load" do
-      expect {subject.load("http://example/")}.to raise_error(NoMethodError)
+    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 "does not respond to #update" do
-      expect {subject.update(RDF::Statement.new)}.to raise_error(NoMethodError)
+    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 "does not respond to #clear" do
-      expect {subject.clear}.to raise_error(NoMethodError)
+    it "calls before_execute" do
+      expect(subject).to receive(:before_execute).with(r, {})
+      subject.execute(r)
     end
 
-    describe "#execute" do
-      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
+    it "calls after_execute" do
+      expect(subject).to receive(:after_execute).with(r, {})
+      subject.execute(r)
     end
-  
-    describe "#delete_statement" do
-      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
+
+    it "returns self" do
+      expect(subject.execute(r)).to eq subject
     end
-  
-    describe "#insert_statement" do
-      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
+
+  describe "#delete_statement" do
+    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
+    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
+end
+
+shared_examples "RDF_Transaction" do |klass|
+  it_behaves_like 'an RDF::Transaction', klass
 end

data/lib/rdf/spec/writable.rb

@@ -1,124 +1,136 @@
 require 'rdf/spec'
 
-module RDF_Writable
-  extend RSpec::SharedContext
+RSpec.shared_examples 'an RDF::Writable' do
   include RDF::Spec::Matchers
 
   before :each do
-    raise '+@writable+ must be defined in a before(:each) block' unless instance_variable_get('@writable')
+    raise 'writable must be defined in with let(:readable)' unless
+      defined? writable
 
     @filename = RDF::Spec::TRIPLES_FILE
     @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
 
-    @supports_context = @writable.respond_to?(:supports?) && @writable.supports?(:context)
+    @supports_context = writable.respond_to?(:supports?) && writable.supports?(:context)
   end
 
-  describe RDF::Writable do
-    subject {@writable}
-    let(:statement) {@statements.detect {|s| s.to_a.all? {|r| r.uri?}}}
-    let(:count) {@statements.size}
-
-    it {should respond_to(:writable?)}
-    its(:writable?) {should == !!subject.writable?}
-  
-    describe "#<<" do
-      it "inserts a reader" do
-        skip("writability") unless subject.writable?
-        reader = RDF::NTriples::Reader.new(File.open(@filename)).to_a
-        subject << reader
-        expect(subject).to have_statement(statement)
-        expect(subject.count).to eq count
-      end
+  subject { writable }
+  let(:statement) {@statements.detect {|s| s.to_a.all? {|r| r.uri?}}}
+  let(:count) {@statements.size}
 
-      it "inserts a graph" do
-        skip("writability") unless subject.writable?
-        graph = RDF::Graph.new << @statements
-        subject << graph
-        expect(subject).to have_statement(statement)
-        expect(subject.count).to eq count
-      end
+  it {should respond_to(:writable?)}
+  its(:writable?) {should == !!subject.writable?}
 
-      it "inserts an enumerable" do
-        skip("writability") unless subject.writable?
-        enumerable = @statements.dup.extend(RDF::Enumerable)
-        subject << enumerable
-        expect(subject).to have_statement(statement)
-        expect(subject.count).to eq count
-      end
+  describe "#<<" do
+    it "inserts a reader" do
+      skip("writability") unless subject.writable?
+      reader = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+      subject << reader
+      expect(subject).to have_statement(statement)
+      expect(subject.count).to eq count
+    end
 
-      it "inserts data responding to #to_rdf" do
-        skip("writability") unless subject.writable?
-        mock = double('mock')
-        allow(mock).to receive(:to_rdf).and_return(@statements)
-        subject << mock
-        expect(subject).to have_statement(statement)
-        expect(subject.count).to eq count
-      end
+    it "inserts a graph" do
+      skip("writability") unless subject.writable?
+      graph = RDF::Graph.new << @statements
+      subject << graph
+      expect(subject).to have_statement(statement)
+      expect(subject.count).to eq count
+    end
 
-      it "inserts a statement" do
-        skip("writability") unless subject.writable?
-        subject << statement
-        expect(subject).to have_statement(statement)
-        expect(subject.count).to eq 1
-      end
+    it "inserts an enumerable" do
+      skip("writability") unless subject.writable?
+      enumerable = @statements.dup.extend(RDF::Enumerable)
+      subject << enumerable
+      expect(subject).to have_statement(statement)
+      expect(subject.count).to eq count
+    end
 
-      it "inserts an invalid statement" do
-        skip("writability") unless subject.writable?
-        s = RDF::Statement.from([nil, nil, nil])
-        expect(s).not_to  be_valid
-        subject << s
-        expect(subject.count).to eq 1
-      end
+    it "inserts data responding to #to_rdf" do
+      skip("writability") unless subject.writable?
+      mock = double('mock')
+      allow(mock).to receive(:to_rdf).and_return(@statements)
+      subject << mock
+      expect(subject).to have_statement(statement)
+      expect(subject.count).to eq count
     end
 
-    context "when inserting statements" do
-      it "should support #insert" do
-        skip("writability") unless subject.writable?
-        expect(subject).to respond_to(:insert)
-      end
+    it "inserts a statement" do
+      skip("writability") unless subject.writable?
+      subject << statement
+      expect(subject).to have_statement(statement)
+      expect(subject.count).to eq 1
+    end
+  end
 
-      it "should not raise errors" do
-        skip("writability") unless subject.writable?
-        expect { subject.insert(statement) }.not_to raise_error
-      end
+  context "when inserting statements" do
+    it "should support #insert" do
+      skip("writability") unless subject.writable?
+      expect(subject).to respond_to(:insert)
+    end
 
-      it "should support inserting one statement at a time" do
-        skip("writability") unless subject.writable?
-        subject.insert(statement)
-        expect(subject).to have_statement(statement)
-      end
+    it "should not raise errors" do
+      skip("writability") unless subject.writable?
+      expect { subject.insert(statement) }.not_to raise_error
+    end
 
-      it "should support inserting multiple statements at a time" do
-        skip("writability") unless subject.writable?
-        subject.insert(*@statements)
-      end
+    it "should support inserting one statement at a time" do
+      skip("writability") unless subject.writable?
+      subject.insert(statement)
+      expect(subject).to have_statement(statement)
+    end
 
-      it "should insert statements successfully" do
-        skip("writability") unless subject.writable?
-        subject.insert(*@statements)
-        expect(subject.count).to eq count
-      end
+    it "should support inserting multiple statements at a time" do
+      skip("writability") unless subject.writable?
+      subject.insert(*@statements)
+    end
 
-      it "should not insert a statement twice" do
-        skip("writability") unless subject.writable?
-        subject.insert(statement)
-        subject.insert(statement)
-        expect(subject.count).to eq 1
-      end
+    it "should insert statements successfully" do
+      skip("writability") unless subject.writable?
+      subject.insert(*@statements)
+      expect(subject.count).to eq count
+    end
+
+    it "should not insert a statement twice" do
+      skip("writability") unless subject.writable?
+      subject.insert(statement)
+      subject.insert(statement)
+      expect(subject.count).to eq 1
+    end
+
+    it "should treat statements with a different context as distinct" do
+      skip("writability") unless subject.writable?
+      s1 = statement.dup
+      s1.context = nil
+      s2 = statement.dup
+      s2.context = RDF::URI.new("urn:context:1")
+      s3 = statement.dup
+      s3.context = RDF::URI.new("urn:context:2")
+      subject.insert(s1)
+      subject.insert(s2)
+      subject.insert(s3)
+      # If contexts are not suported, all three are redundant
+      expect(subject.count).to eq (@supports_context ? 3 : 1)
+    end
+  end
+end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Writable"` instead
+module RDF_Writable
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Writable` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Writable'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Writable' do
+      let(:writable) { @writable }
 
-      it "should treat statements with a different context as distinct" do
-        skip("writability") unless subject.writable?
-        s1 = statement.dup
-        s1.context = nil
-        s2 = statement.dup
-        s2.context = RDF::URI.new("urn:context:1")
-        s3 = statement.dup
-        s3.context = RDF::URI.new("urn:context:2")
-        subject.insert(s1)
-        subject.insert(s2)
-        subject.insert(s3)
-        # If contexts are not suported, all three are redundant
-        expect(subject.count).to eq (@supports_context ? 3 : 1)
+      before do
+        raise '@writable must be defined' unless defined?(writable)
       end
     end
   end

data/lib/rdf/spec/writer.rb

@@ -2,175 +2,197 @@ require 'rdf/spec'
 require 'fileutils'
 require 'tmpdir'
 
-module RDF_Writer
+RSpec.shared_examples 'an RDF::Writer' do
   extend RSpec::SharedContext
-  include RDF::Spec::Matchers
 
   before(:each) do
-    raise '+@writer+ must be defined in a before(:each) block' unless instance_variable_get('@writer')
-    @writer_class = @writer.class
+    raise 'writer must be defined with let(:writer)' unless
+      defined? writer
   end
+  let(:writer_class) { writer.class }
 
-  describe RDF::Writer do
-    describe ".each" do
-      it "yields each writer" do
-        @writer_class.each do |r|
-          expect(r).not_to be_nil
-        end
+  describe ".each" do
+    it "yields each writer" do
+      writer_class.each do |r|
+        expect(r).not_to be_nil
       end
     end
-  
-    describe ".buffer" do
-      it "calls .new with buffer and other arguments" do
-        expect(@writer_class).to receive(:new)
-        @writer_class.buffer do |r|
-          expect(r).to be_a(@writer_class)
-        end
+  end
+
+  describe ".buffer" do
+    it "calls .new with buffer and other arguments" do
+      expect(writer_class).to receive(:new)
+      writer_class.buffer do |r|
+        expect(r).to be_a(writer_class)
       end
     end
+  end
 
-    describe ".open" do
-      before(:each) do
-        allow(RDF::Util::File).to receive(:open_file).and_yield(StringIO.new("foo"))
-        @dir = Dir.mktmpdir
-        @basename = File.join(@dir, "foo")
-      end
-    
-      after(:each) do
-        FileUtils.rm_rf(@dir)
-      end
+  describe ".open" do
+    before(:each) do
+      allow(RDF::Util::File).to receive(:open_file).and_yield(StringIO.new("foo"))
+      @dir = Dir.mktmpdir
+      @basename = File.join(@dir, "foo")
+    end
 
-      it "yields writer given file_name" do
-        @writer_class.format.each do |f|
-          f.file_extensions.each_pair do |sym, content_type|
-            writer_mock = double("writer")
-            expect(writer_mock).to receive(:got_here)
-            expect(@writer_class).to receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(@writer_class)
-            @writer_class.open("#{@basename}.#{sym}") do |r|
-              expect(r).to be_a(RDF::Writer)
-              writer_mock.got_here
-            end
-          end
-        end
-      end
+    after(:each) do
+      FileUtils.rm_rf(@dir)
+    end
 
-      it "yields writer given symbol" do
-        @writer_class.format.each do |f|
-          sym = f.to_sym  # Like RDF::NTriples::Format => :ntriples
+    it "yields writer given file_name" do
+      writer_class.format.each do |f|
+        f.file_extensions.each_pair do |sym, content_type|
           writer_mock = double("writer")
           expect(writer_mock).to receive(:got_here)
-          expect(@writer_class).to receive(:for).with(sym).and_return(@writer_class)
-          @writer_class.open("#{@basename}.#{sym}", :format => sym) do |r|
+          expect(writer_class).to receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(writer_class)
+          writer_class.open("#{@basename}.#{sym}") do |r|
             expect(r).to be_a(RDF::Writer)
             writer_mock.got_here
           end
         end
       end
+    end
 
-      it "yields writer given {:file_name => file_name}" do
-        @writer_class.format.each do |f|
-          f.file_extensions.each_pair do |sym, content_type|
-            writer_mock = double("writer")
-            expect(writer_mock).to receive(:got_here)
-            expect(@writer_class).to receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(@writer_class)
-            @writer_class.open("#{@basename}.#{sym}", :file_name => "#{@basename}.#{sym}") do |r|
-              expect(r).to be_a(RDF::Writer)
-              writer_mock.got_here
-            end
-          end
+    it "yields writer given symbol" do
+      writer_class.format.each do |f|
+        sym = f.to_sym  # Like RDF::NTriples::Format => :ntriples
+        writer_mock = double("writer")
+        expect(writer_mock).to receive(:got_here)
+        expect(writer_class).to receive(:for).with(sym).and_return(writer_class)
+        writer_class.open("#{@basename}.#{sym}", :format => sym) do |r|
+          expect(r).to be_a(RDF::Writer)
+          writer_mock.got_here
         end
       end
+    end
 
-      it "yields writer given {:content_type => 'a/b'}" do
-        @writer_class.format.each do |f|
-          f.content_types.each_pair do |content_type, formats|
-            writer_mock = double("writer")
-            expect(writer_mock).to receive(:got_here)
-            expect(@writer_class).to receive(:for).with(:content_type => content_type, :file_name => @basename).and_return(@writer_class)
-            @writer_class.open(@basename, :content_type => content_type) do |r|
-              expect(r).to be_a(RDF::Writer)
-              writer_mock.got_here
-            end
+    it "yields writer given {:file_name => file_name}" do
+      writer_class.format.each do |f|
+        f.file_extensions.each_pair do |sym, content_type|
+          writer_mock = double("writer")
+          expect(writer_mock).to receive(:got_here)
+          expect(writer_class).to receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(writer_class)
+          writer_class.open("#{@basename}.#{sym}", :file_name => "#{@basename}.#{sym}") do |r|
+            expect(r).to be_a(RDF::Writer)
+            writer_mock.got_here
           end
         end
       end
     end
 
-    describe ".format" do
-      it "returns itself even if given explicit format" do
-        other_format = @writer_class == RDF::NTriples::Writer ? :nquads : :ntriples
-        expect(@writer_class.for(other_format)).to eq @writer_class
+    it "yields writer given {:content_type => 'a/b'}" do
+      writer_class.format.each do |f|
+        f.content_types.each_pair do |content_type, formats|
+          writer_mock = double("writer")
+          expect(writer_mock).to receive(:got_here)
+          expect(writer_class).to receive(:for).with(:content_type => content_type, :file_name => @basename).and_return(writer_class)
+          writer_class.open(@basename, :content_type => content_type) do |r|
+            expect(r).to be_a(RDF::Writer)
+            writer_mock.got_here
+          end
+        end
       end
     end
+  end
 
-    describe ".new" do
-      it "sets @output to $stdout by default" do
-        writer_mock = double("writer")
-        expect(writer_mock).to receive(:got_here)
-        save, $stdout = $stdout, StringIO.new
+  describe ".format" do
+    it "returns itself even if given explicit format" do
+      other_format = writer_class == RDF::NTriples::Writer ? :nquads : :ntriples
+      expect(writer_class.for(other_format)).to eq writer_class
+    end
+  end
 
-        @writer_class.new do |r|
-          writer_mock.got_here
-          expect(r.instance_variable_get(:@output)).to eq $stdout
-        end
-        $stdout = save
+  describe ".new" do
+    it "sets @output to $stdout by default" do
+      writer_mock = double("writer")
+      expect(writer_mock).to receive(:got_here)
+      save, $stdout = $stdout, StringIO.new
+
+      writer_class.new do |r|
+        writer_mock.got_here
+        expect(r.instance_variable_get(:@output)).to eq $stdout
       end
-    
-      it "sets @output to file given something other than a string" do
-        writer_mock = double("writer")
-        expect(writer_mock).to receive(:got_here)
-        file = StringIO.new
-        @writer_class.new(file) do |r|
-          writer_mock.got_here
-          expect(r.instance_variable_get(:@output)).to eq file
-        end
+      $stdout = save
+    end
+
+    it "sets @output to file given something other than a string" do
+      writer_mock = double("writer")
+      expect(writer_mock).to receive(:got_here)
+      file = StringIO.new
+      writer_class.new(file) do |r|
+        writer_mock.got_here
+        expect(r.instance_variable_get(:@output)).to eq file
       end
-    
-      it "sets prefixes given :prefixes => {}" do
-        writer_mock = double("writer")
-        expect(writer_mock).to receive(:got_here)
-        @writer_class.new(StringIO.new, :prefixes => {:a => "b"}) do |r|
-          writer_mock.got_here
-          expect(r.prefixes).to eq({:a => "b"})
-        end
+    end
+
+    it "sets prefixes given :prefixes => {}" do
+      writer_mock = double("writer")
+      expect(writer_mock).to receive(:got_here)
+      writer_class.new(StringIO.new, :prefixes => {:a => "b"}) do |r|
+        writer_mock.got_here
+        expect(r.prefixes).to eq({:a => "b"})
       end
-    
-      #it "calls #write_prologue" do
-      #  writer_mock = double("writer")
-      #  writer_mock.should_receive(:got_here)
-      #  @writer_class.any_instance.should_receive(:write_prologue)
-      #  @writer_class.new(StringIO.new) do |r|
-      #    writer_mock.got_here
-      #  end
-      #end
-      #
-      #it "calls #write_epilogue" do
-      #  writer_mock = double("writer")
-      #  writer_mock.should_receive(:got_here)
-      #  @writer_class.any_instance.should_receive(:write_epilogue)
-      #  @writer_class.new(StringIO.new) do |r|
-      #    writer_mock.got_here
-      #  end
-      #end
     end
-  
-    describe "#prefixes=" do
-      it "sets prefixes from hash" do
-        @writer.prefixes = {:a => "b"}
-        expect(@writer.prefixes).to eq({:a => "b"})
+
+    #it "calls #write_prologue" do
+    #  writer_mock = double("writer")
+    #  writer_mock.should_receive(:got_here)
+    #  writer_class.any_instance.should_receive(:write_prologue)
+    #  writer_class.new(StringIO.new) do |r|
+    #    writer_mock.got_here
+    #  end
+    #end
+    #
+    #it "calls #write_epilogue" do
+    #  writer_mock = double("writer")
+    #  writer_mock.should_receive(:got_here)
+    #  writer_class.any_instance.should_receive(:write_epilogue)
+    #  writer_class.new(StringIO.new) do |r|
+    #    writer_mock.got_here
+    #  end
+    #end
+  end
+
+  describe "#prefixes=" do
+    it "sets prefixes from hash" do
+      writer.prefixes = {:a => "b"}
+      expect(writer.prefixes).to eq({:a => "b"})
+    end
+  end
+
+  describe "#prefix" do
+    {
+      nil     => "nil",
+      :a      => "b",
+      "foo"   => "bar",
+    }.each_pair do |pfx, uri|
+      it "sets prefix(#{pfx}) to #{uri}" do
+        expect(writer.prefix(pfx, uri)).to eq uri
+        expect(writer.prefix(pfx)).to eq uri
       end
     end
-  
-    describe "#prefix" do
-      {
-        nil     => "nil",
-        :a      => "b",
-        "foo"   => "bar",
-      }.each_pair do |pfx, uri|
-        it "sets prefix(#{pfx}) to #{uri}" do
-          expect(@writer.prefix(pfx, uri)).to eq uri
-          expect(@writer.prefix(pfx)).to eq uri
-        end
+  end
+end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Writer"` instead
+module RDF_Writer
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Writer` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Writer'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Writer' do
+      let(:writer_class) { @writer_class }
+      let(:writer) { @writer }
+
+      before do
+        raise '@writer_class must be defined' unless defined?(writer_class)
+        raise '@writer must be defined' unless defined?(writer)
       end
     end
   end