Rename instance variables used in specs to be localized so as not to confuse with the same variable that could be named in the surrounding context.

Author: gkellogg

lib/rdf/spec/enumerable.rb

@@ -7,25 +7,24 @@
     raise 'enumerable must be set with `let(:enumerable)' unless
       defined? enumerable
 
-    @statements ||= RDF::Spec.quads
+    @rdf_enumerable_iv_statements ||= RDF::Spec.quads
 
     if enumerable.empty?
       if (enumerable.writable? rescue false)
-        enumerable.insert(*@statements)
+        enumerable.insert(*@rdf_enumerable_iv_statements)
       elsif enumerable.respond_to?(:<<)
-        @statements.each { |statement| enumerable << statement }
+        @rdf_enumerable_iv_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_named_graphs = enumerable.supports?(:graph_name) rescue true
   end
 
-  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(&:node?)}
-  let(:non_bnode_terms) {@statements.map(&:to_quad).flatten.compact.reject(&:node?).uniq}
+  let(:supports_named_graphs) {enumerable.supports?(:graph_name) rescue true}
+  let(:subject_count) {@rdf_enumerable_iv_statements.map(&:subject).uniq.length}
+  let(:bnode_subject_count) {@rdf_enumerable_iv_statements.map(&:subject).uniq.select(&:node?).length}
+  let(:non_bnode_statements) {@rdf_enumerable_iv_statements.reject(&:node?)}
+  let(:non_bnode_terms) {@rdf_enumerable_iv_statements.map(&:to_quad).flatten.compact.reject(&:node?).uniq}
 
   subject { enumerable }
   it {is_expected.to respond_to(:supports?)}
@@ -57,9 +56,9 @@
     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}
+    its(:count) {is_expected.to eq @rdf_enumerable_iv_statements.size}
     it {is_expected.to respond_to(:size)}
-    its(:size) {is_expected.to eq @statements.size}
+    its(:size) {is_expected.to eq @rdf_enumerable_iv_statements.size}
 
     context "and empty" do
       subject {[].extend(RDF::Enumerable)}
@@ -74,7 +73,7 @@
     its(:statements) {is_expected.to be_a(Array)}
 
     context "#statements" do
-      specify {expect(subject.statements.size).to eq @statements.size}
+      specify {expect(subject.statements.size).to eq @rdf_enumerable_iv_statements.size}
       specify {expect(subject.statements).to all(be_a_statement)}
     end
 
@@ -89,7 +88,7 @@
       end
 
       it "does not have statement in different named graph" do
-        if @supports_named_graphs
+        if supports_named_graphs
           graph_name = RDF::URI.new("urn:graph_name:1")
           non_bnode_statements.each do |statement|
             s = statement.dup
@@ -132,7 +131,7 @@
 
     its(:triples) {is_expected.to be_a(Array)}
     context "#triples" do
-      specify {expect(subject.triples.size).to eq @statements.size}
+      specify {expect(subject.triples.size).to eq @rdf_enumerable_iv_statements.size}
       specify {expect(subject.triples).to all(be_a_triple)}
     end
 
@@ -176,13 +175,13 @@
 
     its(:quads) {is_expected.to be_a(Array)}
     context "#quads" do
-      specify {expect(subject.quads.size).to eq @statements.size}
+      specify {expect(subject.quads.size).to eq @rdf_enumerable_iv_statements.size}
       specify {expect(subject.quads).to all(be_a_quad)}
     end
 
     context "#has_quad?" do
       specify do
-        if @supports_named_graphs
+        if supports_named_graphs
           non_bnode_statements.each do |statement|
             is_expected.to have_quad(statement.to_quad)
           end
@@ -265,7 +264,7 @@
   end
 
   context "when enumerating predicates" do
-    let(:predicates) {@statements.map { |s| s.predicate }.uniq}
+    let(:predicates) {@rdf_enumerable_iv_statements.map { |s| s.predicate }.uniq}
     it {is_expected.to respond_to(:predicates)}
     it {is_expected.to respond_to(:has_predicate?)}
     it {is_expected.to respond_to(:each_predicate)}
@@ -285,7 +284,7 @@
     context "#has_predicate?" do
       specify do
         checked = []
-        @statements.each do |statement|
+        @rdf_enumerable_iv_statements.each do |statement|
           expect(enumerable).to have_predicate(statement.predicate) unless checked.include?(statement.predicate)
           checked << statement.predicate
         end
@@ -434,8 +433,8 @@
     end
 
     it "should implement #has_graph?" do
-      if @supports_named_graphs
-        @statements.each do |statement|
+      if supports_named_graphs
+        @rdf_enumerable_iv_statements.each do |statement|
           if statement.has_graph?
             expect(enumerable).to have_graph(statement.graph_name)
           end
@@ -480,21 +479,21 @@
 
       context "non-existing graph" do
         let(:graph_name) {RDF::URI.new('http://example.org/does/not/have/this/uri')}
-        specify {expect(subject.project_graph(graph_name)).to be_empty if @supports_named_graphs}
+        specify {expect(subject.project_graph(graph_name)).to be_empty if supports_named_graphs}
       end
     end
 
     its(:each_graph) {is_expected.to be_an_enumerator}
 
     describe "#each_graph" do
-      let(:graph_names) {@statements.map { |s| s.graph_name }.uniq.compact}
+      let(:graph_names) {@rdf_enumerable_iv_statements.map { |s| s.graph_name }.uniq.compact}
       subject { enumerable.each_graph }
       it {is_expected.to be_an_enumerator}
-      specify {is_expected.to all(be_a_graph) if @supports_named_graphs}
+      specify {is_expected.to all(be_a_graph) if supports_named_graphs}
 
       it "has appropriate number of graphs" do
-        if @supports_named_graphs
-          graph_names = @statements.map { |s| s.graph_name }.uniq.compact
+        if supports_named_graphs
+          graph_names = @rdf_enumerable_iv_statements.map { |s| s.graph_name }.uniq.compact
           expect(subject.to_a.size).to eq (graph_names.size + 1)
         end
       end
@@ -505,7 +504,7 @@
       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_named_graphs # 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

lib/rdf/spec/matchers.rb

@@ -193,7 +193,7 @@ module Matchers
     end
 
     RSpec::Matchers.define :write do |message|
-      chain(:to) { |io| @io = io }
+      chain(:to) { |io| @rdf_matcher_iv_io = io }
 
       supports_block_expectations { true }
 
@@ -256,7 +256,7 @@ def fake_stdout
 
       # default IO is standard output
       def io
-        @io ||= :output
+        @rdf_matcher_iv_io ||= :output
       end
 
       # IO name is used for description message

lib/rdf/spec/mutable.rb

@@ -9,14 +9,14 @@
       defined? mutable
 
     skip "Immutable resource" unless mutable.mutable?
-    @statements = RDF::Spec.triples
+    @rdf_mutable_iv_statements = RDF::Spec.triples
     @supports_named_graphs = mutable.respond_to?(:supports?) && mutable.supports?(:graph_name)
     @supports_literal_equality = mutable.respond_to?(:supports?) && mutable.supports?(:literal_equality)
   end
 
   let(:resource) { RDF::URI('http://rubygems.org/gems/rdf') }
   let(:graph_name) { RDF::URI('http://example.org/graph_name') }
-  let(:non_bnode_statements) {@statements.reject(&:node?)}
+  let(:non_bnode_statements) {@rdf_mutable_iv_statements.reject(&:node?)}
 
   describe RDF::Mutable do
     subject { mutable }
@@ -139,7 +139,7 @@
 
     context "when deleting statements" do
       before :each do
-        subject.insert(*@statements)
+        subject.insert(*@rdf_mutable_iv_statements)
       end
 
       it "should not raise errors" do
@@ -152,7 +152,7 @@
       end
 
       it "should support deleting multiple statements at a time" do
-        subject.delete(*@statements)
+        subject.delete(*@rdf_mutable_iv_statements)
         expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
       end
 
@@ -234,13 +234,13 @@
         end
 
         it 'deletes and inserts' do
-          subject.delete_insert(@statements, [statement])
+          subject.delete_insert(@rdf_mutable_iv_statements, [statement])
           is_expected.to contain_exactly statement
         end
 
         it 'deletes before inserting' do
-          subject.delete_insert(@statements, [@statements.first])
-          is_expected.to contain_exactly @statements.first
+          subject.delete_insert(@rdf_mutable_iv_statements, [@rdf_mutable_iv_statements.first])
+          is_expected.to contain_exactly @rdf_mutable_iv_statements.first
         end
 
         it 'deletes patterns' do
@@ -276,7 +276,7 @@
             if subject.mutable? && subject.supports?(:atomic_write)
               contents = subject.statements.to_a
 
-              expect { subject.delete_insert(@statements, [nil]) }
+              expect { subject.delete_insert(@rdf_mutable_iv_statements, [nil]) }
                 .to raise_error ArgumentError
               expect(subject.statements).to contain_exactly(*contents)
             end

lib/rdf/spec/queryable.rb

@@ -7,16 +7,16 @@
     raise 'querable must be set with `let(:queryable)' unless
       defined? queryable
 
-    @doap = RDF::Spec::QUADS_FILE
-    @statements = RDF::Spec.quads
+    @rdf_queryable_iv_doap = RDF::Spec::QUADS_FILE
+    @rdf_queryable_iv_statements = RDF::Spec.quads
 
     if queryable.empty?
       if (queryable.writable? rescue false)
-        queryable.insert(*@statements)
+        queryable.insert(*@rdf_queryable_iv_statements)
       elsif queryable.respond_to?(:<<)
-        @statements.each { |statement| queryable << statement }
+        @rdf_queryable_iv_statements.each { |statement| queryable << statement }
       else
-        raise "queryable must respond to #<< or be pre-populated with the statements in #{@doap} in a before(:each) block"
+        raise "queryable must respond to #<< or be pre-populated with the statements in #{@rdf_queryable_iv_doap} in a before(:each) block"
       end
     end
   end
@@ -95,7 +95,7 @@
           pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: nil)
           solutions = []
           subject.send(method, pattern) {|s| solutions << s}
-          expect(solutions.size).to eq @statements.size
+          expect(solutions.size).to eq @rdf_queryable_iv_statements.size
         end
 
         it "returns statements from named graphs with variable graph_name" do
@@ -114,7 +114,7 @@
             pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: RDF::URI("http://ar.to/#self"))
             solutions = []
             subject.send(method, pattern) {|s| solutions << s}
-            expect(solutions.size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
+            expect(solutions.size).to eq File.readlines(@rdf_queryable_iv_doap).grep(/^<http:\/\/ar.to\/\#self>/).size
           end
         end
       end
@@ -233,22 +233,22 @@
             end
 
             it "returns the correct number of results for array queries" do
-              expect(subject.query([nil, nil, nil]).size).to eq @statements.size
-              expect(subject.query([resource, nil, nil]).size).to eq File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
-              expect(subject.query([RDF::URI("http://ar.to/#self"), nil, nil]).size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
+              expect(subject.query([nil, nil, nil]).size).to eq @rdf_queryable_iv_statements.size
+              expect(subject.query([resource, nil, nil]).size).to eq File.readlines(@rdf_queryable_iv_doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
+              expect(subject.query([RDF::URI("http://ar.to/#self"), nil, nil]).size).to eq File.readlines(@rdf_queryable_iv_doap).grep(/^<http:\/\/ar.to\/\#self>/).size
               expect(subject.query([resource, RDF::URI("http://usefulinc.com/ns/doap#name"), nil]).size).to eq 1
               expect(subject.query([nil, nil, RDF::URI("http://usefulinc.com/ns/doap#Project")]).size).to eq 1
             end
 
             it "returns the correct number of results for hash queries" do
-              expect(subject.query({}).size).to eq @statements.size
-              expect(subject.query(subject: resource).size).to eq File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
+              expect(subject.query({}).size).to eq @rdf_queryable_iv_statements.size
+              expect(subject.query(subject: resource).size).to eq File.readlines(@rdf_queryable_iv_doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
               expect(subject.query(subject: resource, predicate: RDF::URI("http://usefulinc.com/ns/doap#name")).size).to eq 1
               expect(subject.query(object: RDF::URI("http://usefulinc.com/ns/doap#Project")).size).to eq 1
             end
 
             it "returns the correct number of results for query queries" do
-              expect(subject.query(query).size).to eq @statements.size
+              expect(subject.query(query).size).to eq @rdf_queryable_iv_statements.size
             end
           end
         end

lib/rdf/spec/repository.rb

@@ -7,9 +7,8 @@
     raise 'repository must be set with `let(:repository)' unless
       defined? repository
 
-    @statements = RDF::Spec.quads
     if repository.empty? && repository.writable?
-      repository.insert(*@statements)
+      repository.insert(*RDF::Spec.quads)
     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

lib/rdf/spec/transactable.rb

@@ -3,7 +3,7 @@
 RSpec.shared_examples 'an RDF::Transactable' do
   include RDF::Spec::Matchers
 
-  let(:statements) { RDF::Spec.quads }
+  let(:statements) { @rdf_transactable_iv_statements = RDF::Spec.quads }
 
   before do
     raise '`transactable` must be set with `let(:transactable)`' unless
@@ -34,7 +34,7 @@
 
       expect do
         subject.transaction(mutable: true) do
-          delete(*@statements)
+          delete(*statements)
           raise 'my error'
         end
       end.to raise_error RuntimeError