rdf-spec 1.1.5 → 1.1.13

data/lib/rdf/spec/readable.rb

@@ -1,16 +1,39 @@
 require 'rdf/spec'
 
+RSpec.shared_examples 'an RDF::Readable' do
+  include RDF::Spec::Matchers
+
+  before do
+    raise 'readable must be defined in with let(:readable)' unless
+      defined? readable
+  end
+
+  describe RDF::Readable do
+    subject { readable }
+    it { is_expected.to respond_to :readable? }
+    it { is_expected.to respond_to :readable? }
+    its(:readable?) { is_expected.to eq subject.readable? }
+  end
+end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Readable"` instead
 module RDF_Readable
   extend RSpec::SharedContext
   include RDF::Spec::Matchers
 
-  before :each do
-    raise '+@readable+ must be defined in a before(:each) block' unless instance_variable_get('@readable')
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Readable` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Readable'`"
   end
 
-  describe RDF::Readable do
-    subject {@readable}
-    it {should respond_to(:readable?)}
-    its(:readable?) {should == subject.readable?}
+  describe 'examples for' do
+    include_examples 'an RDF::Readable' do
+      let(:readable) { @readable }
+
+      before do
+        raise '@readable must be defined' unless defined?(readable)
+      end
+    end
   end
 end

data/lib/rdf/spec/reader.rb

@@ -1,208 +1,234 @@
 require 'rdf/spec'
 
-module RDF_Reader
+RSpec.shared_examples 'an RDF::Reader' do
   extend RSpec::SharedContext
-  include RDF::Spec::Matchers
 
   before(:each) do
-    raise '+@reader+ must be defined in a before(:each) block' unless instance_variable_get('@reader')
-    raise '+@reader_input+ must be defined in a before(:each) block' unless instance_variable_get('@reader_input')
-    raise '+@reader_count+ must be defined in a before(:each) block' unless instance_variable_get('@reader_count')
-    @reader_class = @reader.class
+    raise 'reader must be defined with let(:reader)' unless defined? reader
+    raise 'reader_input must be defined with let(:reader_input)' unless defined? reader_input
+    raise 'reader_count must be defined with let(:reader_count)' unless defined? reader_count
   end
 
-  describe RDF::Reader do
-    describe ".each" do
-      it "yields each reader" do
-        @reader_class.each do |r|
-          expect(r).not_to  be_nil
-        end
+  let(:reader_class) { reader.class }
+
+  describe ".each" do
+    it "yields each reader" do
+      reader_class.each do |r|
+        expect(r).not_to  be_nil
       end
     end
+  end
 
-    describe ".open" do
-      before(:each) do
-        allow(RDF::Util::File).to receive(:open_file).and_yield(StringIO.new(@reader_input))
-      end
+  describe ".open" do
+    before(:each) do
+      allow(RDF::Util::File).to receive(:open_file).and_yield(StringIO.new(reader_input))
+    end
 
-      it "yields reader given file_name" do
-        @reader_class.format.each do |f|
-          f.file_extensions.each_pair do |sym, content_type|
-            reader_mock = double("reader")
-            expect(reader_mock).to receive(:got_here)
-            expect(@reader_class).to receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
-            @reader_class.open("foo.#{sym}") do |r|
-              expect(r).to be_a(RDF::Reader)
-              reader_mock.got_here
-            end
+    it "yields reader given file_name" do
+      reader_class.format.each do |f|
+        f.file_extensions.each_pair do |sym, content_type|
+          reader_mock = double("reader")
+          expect(reader_mock).to receive(:got_here)
+          expect(reader_class).to receive(:for).with(:file_name => "foo.#{sym}").and_return(reader_class)
+          reader_class.open("foo.#{sym}") do |r|
+            expect(r).to be_a(RDF::Reader)
+            reader_mock.got_here
           end
         end
       end
+    end
 
-      it "yields reader given symbol" do
-        @reader_class.format.each do |f|
-          sym = f.to_sym  # Like RDF::NTriples::Format => :ntriples
+    it "yields reader given symbol" do
+      reader_class.format.each do |f|
+        sym = f.to_sym  # Like RDF::NTriples::Format => :ntriples
+        reader_mock = double("reader")
+        expect(reader_mock).to receive(:got_here)
+        expect(reader_class).to receive(:for).with(sym).and_return(reader_class)
+        reader_class.open("foo.#{sym}", :format => sym) do |r|
+          expect(r).to be_a(RDF::Reader)
+          reader_mock.got_here
+        end
+      end
+    end
+
+    it "yields reader given {:file_name => file_name}" do
+      reader_class.format.each do |f|
+        f.file_extensions.each_pair do |sym, content_type|
           reader_mock = double("reader")
           expect(reader_mock).to receive(:got_here)
-          expect(@reader_class).to receive(:for).with(sym).and_return(@reader_class)
-          @reader_class.open("foo.#{sym}", :format => sym) do |r|
+          expect(reader_class).to receive(:for).with(:file_name => "foo.#{sym}").and_return(reader_class)
+          reader_class.open("foo.#{sym}", :file_name => "foo.#{sym}") do |r|
             expect(r).to be_a(RDF::Reader)
             reader_mock.got_here
           end
         end
       end
+    end
 
-      it "yields reader given {:file_name => file_name}" do
-        @reader_class.format.each do |f|
-          f.file_extensions.each_pair do |sym, content_type|
-            reader_mock = double("reader")
-            expect(reader_mock).to receive(:got_here)
-            expect(@reader_class).to receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
-            @reader_class.open("foo.#{sym}", :file_name => "foo.#{sym}") do |r|
-              expect(r).to be_a(RDF::Reader)
-              reader_mock.got_here
-            end
+    it "yields reader given {:content_type => 'a/b'}" do
+      reader_class.format.each do |f|
+        f.content_types.each_pair do |content_type, formats|
+          reader_mock = double("reader")
+          expect(reader_mock).to receive(:got_here)
+          expect(reader_class).to receive(:for).with(:content_type => content_type, :file_name => "foo").and_return(reader_class)
+          reader_class.open("foo", :content_type => content_type) do |r|
+            expect(r).to be_a(RDF::Reader)
+            reader_mock.got_here
           end
         end
       end
+    end
+  end
 
-      it "yields reader given {:content_type => 'a/b'}" do
-        @reader_class.format.each do |f|
-          f.content_types.each_pair do |content_type, formats|
-            reader_mock = double("reader")
-            expect(reader_mock).to receive(:got_here)
-            expect(@reader_class).to receive(:for).with(:content_type => content_type, :file_name => "foo").and_return(@reader_class)
-            @reader_class.open("foo", :content_type => content_type) do |r|
-              expect(r).to be_a(RDF::Reader)
-              reader_mock.got_here
-            end
-          end
-        end
-      end
+  describe ".format" do
+    it "returns itself even if given explicit format" do
+      other_format = reader_class == RDF::NTriples::Reader ? :nquads : :ntriples
+      expect(reader_class.for(other_format)).to eq reader_class
     end
+  end
 
-    describe ".format" do
-      it "returns itself even if given explicit format" do
-        other_format = @reader_class == RDF::NTriples::Reader ? :nquads : :ntriples
-        expect(@reader_class.for(other_format)).to eq @reader_class
+  describe ".new" do
+    it "sets @input to StringIO given a string" do
+      reader_mock = double("reader")
+      expect(reader_mock).to receive(:got_here)
+      reader_class.new(reader_input) do |r|
+        reader_mock.got_here
+        expect(r.instance_variable_get(:@input)).to be_a(StringIO)
       end
     end
 
-    describe ".new" do
-      it "sets @input to StringIO given a string" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
-        @reader_class.new(@reader_input) do |r|
-          reader_mock.got_here
-          expect(r.instance_variable_get(:@input)).to be_a(StringIO)
-        end
+    it "sets @input to input given something other than a string" do
+      reader_mock = double("reader")
+      expect(reader_mock).to receive(:got_here)
+      file = StringIO.new(reader_input)
+      reader_class.new(file) do |r|
+        reader_mock.got_here
+        expect(r.instance_variable_get(:@input)).to eq file
       end
+    end
 
-      it "sets @input to input given something other than a string" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
-        file = StringIO.new(@reader_input)
-        @reader_class.new(file) do |r|
-          reader_mock.got_here
-          expect(r.instance_variable_get(:@input)).to eq file
-        end
+    it "sets validate given :validate => true" do
+      reader_class.new(reader_input, :validate => true) do |r|
+        expect(r).to be_valid
       end
+    end
 
-      it "sets validate given :validate => true" do
-        @reader_class.new(@reader_input, :validate => true) do |r|
-          expect(r).to be_valid
-        end
-      end
-    
-      it "sets canonicalize given :canonicalize => true" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
-        @reader_class.new(@reader_input, :canonicalize => true) do |r|
-          reader_mock.got_here
-          expect(r).to be_canonicalize
-        end
-      end
-    
-      it "sets intern given :intern => true" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
-        @reader_class.new(@reader_input, :intern => true) do |r|
-          reader_mock.got_here
-          expect(r).to be_intern
-        end
-      end
-    
-      it "sets prefixes given :prefixes => {}" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
-        @reader_class.new(@reader_input, :prefixes => {:a => "b"}) do |r|
-          reader_mock.got_here
-          expect(r.prefixes).to eq({:a => "b"})
-        end
+    it "sets canonicalize given :canonicalize => true" do
+      reader_mock = double("reader")
+      expect(reader_mock).to receive(:got_here)
+      reader_class.new(reader_input, :canonicalize => true) do |r|
+        reader_mock.got_here
+        expect(r).to be_canonicalize
       end
     end
-  
-    describe "#prefixes=" do
-      it "sets prefixes from hash" do
-        @reader.prefixes = {:a => "b"}
-        expect(@reader.prefixes).to eq({:a => "b"})
+
+    it "sets intern given :intern => true" do
+      reader_mock = double("reader")
+      expect(reader_mock).to receive(:got_here)
+      reader_class.new(reader_input, :intern => true) do |r|
+        reader_mock.got_here
+        expect(r).to be_intern
       end
     end
-  
-    describe "#prefix" do
-      {
-        nil     => "nil",
-        :a      => "b",
-        "foo"   => "bar",
-      }.each_pair do |pfx, uri|
-        it "sets prefix(#{pfx}) to #{uri}" do
-          expect(@reader.prefix(pfx, uri)).to eq uri
-          expect(@reader.prefix(pfx)).to eq uri
-        end
+
+    it "sets prefixes given :prefixes => {}" do
+      reader_mock = double("reader")
+      expect(reader_mock).to receive(:got_here)
+      reader_class.new(reader_input, :prefixes => {:a => "b"}) do |r|
+        reader_mock.got_here
+        expect(r.prefixes).to eq({:a => "b"})
       end
     end
+  end
 
-    context RDF::Enumerable do
-      it "#count" do
-        @reader_class.new(@reader_input) {|r| expect(r.count).to eq @reader_count}
-      end
-      it "#empty?" do
-        @reader_class.new(@reader_input) {|r| expect(r).not_to be_empty}
-      end
+  describe "#prefixes=" do
+    it "sets prefixes from hash" do
+      reader.prefixes = {:a => "b"}
+      expect(reader.prefixes).to eq({:a => "b"})
+    end
+  end
 
-      it "#statements" do
-        @reader_class.new(@reader_input) {|r| expect(r.statements.count).to eq @reader_count}
-      end
-      it "#has_statement?" do
-        @reader_class.new(@reader_input) {|r| expect(r).to respond_to(:has_statement?)}
-      end
-      it "#each_statement" do
-        @reader_class.new(@reader_input) {|r| expect(r.each_statement.count).to eq @reader_count}
-      end
-      it "#enum_statement" do
-        @reader_class.new(@reader_input) {|r| expect(r.enum_statement.count).to eq @reader_count}
+  describe "#prefix" do
+    {
+      nil     => "nil",
+      :a      => "b",
+      "foo"   => "bar",
+    }.each_pair do |pfx, uri|
+      it "sets prefix(#{pfx}) to #{uri}" do
+        expect(reader.prefix(pfx, uri)).to eq uri
+        expect(reader.prefix(pfx)).to eq uri
       end
+    end
+  end
 
-      it "#triples" do
-        @reader_class.new(@reader_input) {|r| expect(r.triples.count).to eq @reader_count}
-      end
-      it "#each_triple" do
-        @reader_class.new(@reader_input) {|r| expect(r.each_triple.count).to eq @reader_count}
-      end
-      it "#enum_triple" do
-        @reader_class.new(@reader_input) {|r| expect(r.enum_triple.count).to eq @reader_count}
-      end
+  context RDF::Enumerable do
+    it "#count" do
+      reader_class.new(reader_input) {|r| expect(r.count).to eq reader_count}
+    end
+    it "#empty?" do
+      reader_class.new(reader_input) {|r| expect(r).not_to be_empty}
+    end
 
-      it "#quads" do
-        @reader_class.new(@reader_input) {|r| expect(r.quads.count).to eq @reader_count}
-      end
-      it "#each_quad" do
-        @reader_class.new(@reader_input) {|r| expect(r.each_quad.count).to eq @reader_count}
-      end
-      it "#enum_quad" do
-        @reader_class.new(@reader_input) {|r| expect(r.enum_quad.count).to eq @reader_count}
-      end
+    it "#statements" do
+      reader_class.new(reader_input) {|r| expect(r.statements.count).to eq reader_count}
+    end
+    it "#has_statement?" do
+      reader_class.new(reader_input) {|r| expect(r).to respond_to(:has_statement?)}
+    end
+    it "#each_statement" do
+      reader_class.new(reader_input) {|r| expect(r.each_statement.count).to eq reader_count}
+    end
+    it "#enum_statement" do
+      reader_class.new(reader_input) {|r| expect(r.enum_statement.count).to eq reader_count}
+    end
 
+    it "#triples" do
+      reader_class.new(reader_input) {|r| expect(r.triples.count).to eq reader_count}
+    end
+    it "#each_triple" do
+      reader_class.new(reader_input) {|r| expect(r.each_triple.count).to eq reader_count}
+    end
+    it "#enum_triple" do
+      reader_class.new(reader_input) {|r| expect(r.enum_triple.count).to eq reader_count}
+    end
+
+    it "#quads" do
+      reader_class.new(reader_input) {|r| expect(r.quads.count).to eq reader_count}
+    end
+    it "#each_quad" do
+      reader_class.new(reader_input) {|r| expect(r.each_quad.count).to eq reader_count}
+    end
+    it "#enum_quad" do
+      reader_class.new(reader_input) {|r| expect(r.enum_quad.count).to eq reader_count}
+    end
+
+  end
+end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Reader"` instead
+module RDF_Reader
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Reader` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Reader'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Reader' do
+      let(:reader) { @reader }
+      let(:reader_input) { @reader_input }
+      let(:reader_count) { @reader_count }
+      let(:reader_class) { @reader_class }
+
+      before do
+        raise '@reader must be defined' unless defined?(reader)
+        raise '@reader_input must be defined' unless defined?(reader_input)
+        raise '@reader_count must be defined' unless defined?(reader_count)
+        raise '@reader_class must be defined' unless defined?(reader_class)
+      end
     end
   end
 end

data/lib/rdf/spec/repository.rb

@@ -1,59 +1,80 @@
 require 'rdf/spec'
 
-module RDF_Repository
-  extend RSpec::SharedContext
+RSpec.shared_examples 'an RDF::Repository' do
   include RDF::Spec::Matchers
 
   before :each do
-    raise '+@repository+ must be defined in a before(:each) block' unless instance_variable_get('@repository')
+    raise 'repository must be set with `let(:repository)' unless
+      defined? repository
+
     @statements = RDF::Spec.quads
-    if @repository.empty? && @repository.writable?
-      @repository.insert(*@statements)
-    elsif @repository.empty?
+    if repository.empty? && repository.writable?
+      repository.insert(*@statements)
+    elsif repository.empty?
       raise "+@repository+ must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
     end
-    @countable = @repository
-    @enumerable = @repository
-    @queryable = @repository
-    @mutable = @repository
   end
 
-  describe RDF::Repository do
+  let(:countable) { repository }
+  let(:enumerable) { repository }
+  let(:queryable) { repository }
+  let(:mutable) { repository }
 
-    context "when counting statements" do
-      require 'rdf/spec/countable'
-      include RDF_Countable
-    end
+  context "when counting statements" do
+    require 'rdf/spec/countable'
+    it_behaves_like 'an RDF::Countable'
+  end
 
-    context "when enumerating statements" do
-      require 'rdf/spec/enumerable'
-      include RDF_Enumerable
-    end
+  context "when enumerating statements" do
+    require 'rdf/spec/enumerable'
+    it_behaves_like 'an RDF::Enumerable'
+  end
 
-    context "when querying statements" do
-      require 'rdf/spec/queryable'
-      include RDF_Queryable
-    end
+  context "when querying statements" do
+    require 'rdf/spec/queryable'
+    it_behaves_like 'an RDF::Queryable'
+  end
 
-    # FIXME: This should be condition on the repository being mutable
-    context "when updating" do
-      require 'rdf/spec/mutable'
-      before(:each) do
-        @mutable.clear
-      end
-      include RDF_Mutable
+  # FIXME: This should be condition on the repository being mutable
+  context "when updating" do
+    require 'rdf/spec/mutable'
+
+    before { mutable.clear }
+
+    it_behaves_like 'an RDF::Mutable'
+  end
+
+  # FIXME: This should be condition on the repository being mutable
+  context "as a durable repository" do
+    require 'rdf/spec/durable'
+
+    before :each do
+      repository.clear
+      @load_durable ||= lambda { repository }
     end
 
-    # FIXME: This should be condition on the repository being mutable
-    context "as a durable repository" do
-      require 'rdf/spec/durable'
+    it_behaves_like 'an RDF::Durable'
+  end
+end
 
-      before :each do
-        @repository.clear
-        @load_durable ||= lambda { @repository }
-      end
+##
+# @deprecated use `it_behaves_like "an RDF::Repository"` instead
+module RDF_Repository
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Repository` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Repository'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Repository' do
+      let(:repository) { @repository }
 
-      include RDF_Durable
+      before do
+        raise '@repository must be defined' unless defined?(repository)
+      end
     end
   end
 end