Add rubocope-rspec, do a pass over all specs to clean some up

Author: aetherknight

.rubocop.yml

@@ -10,6 +10,7 @@
 # See https://docs.rubocop.org/rubocop/configuration
 plugins:
   - 'rubocop-rake'
+  - 'rubocop-rspec'
 
 Layout/LineLength:
   Max: 120
@@ -42,3 +43,14 @@ Gemspec/RequiredRubyVersion:
 # is to officially support supported Ruby versions (and JRuby), but to not
 # officially support no-longer-maintained Ruby versions.
 
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/NestedGroups:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Enabled: false
+
+# Not sure why this one still fails -- the specs are all in a
+# recursive_open_struct directory.
+RSpec/SpecFilePathFormat:
+  Enabled: false

recursive-open-struct.gemspec

@@ -43,6 +43,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rspec', '~> 3.2')
   s.add_development_dependency('rubocop', ['>= 0'])
   s.add_development_dependency('rubocop-rake', ['>= 0'])
+  s.add_development_dependency('rubocop-rspec', ['>= 0'])
   s.add_development_dependency('simplecov', ['>= 0'])
 
   s.add_dependency('ostruct')

spec/recursive_open_struct/debug_inspect_spec.rb

@@ -5,68 +5,42 @@
 
 describe RecursiveOpenStruct do
   describe '#debug_inspect' do
-    before(:each) do
+    subject(:ros) do
       h1 = { a: 'a' }
       h2 = { a: 'b', h1: h1 }
       h1[:h2] = h2
-      @ros = RecursiveOpenStruct.new(h2)
+
+      described_class.new(h2)
     end
 
-    it 'should have a simple way of display' do
-      @output = <<~QUOTE
-        a = "b"
-        h1.
-          a = "a"
-          h2.
-            a = "b"
-            h1.
-              a = "a"
-              h2.
-                a = "b"
-                h1.
-                  a = "a"
-                  h2.
-                    a = "b"
-                    h1.
-                      a = "a"
-                      h2.
-                        a = "b"
-                        h1.
-                          a = "a"
-                          h2.
-                            a = "b"
-                            h1.
-                              a = "a"
-                              h2.
-                                (recursion limit reached)
-      QUOTE
-      @io = StringIO.new
-      @ros.debug_inspect(@io)
-      expect(@io.string).to match(/^a = "b"$/)
-      expect(@io.string).to match(/^h1\.$/)
-      expect(@io.string).to match(/^  a = "a"$/)
-      expect(@io.string).to match(/^  h2\.$/)
-      expect(@io.string).to match(/^    a = "b"$/)
-      expect(@io.string).to match(/^    h1\.$/)
-      expect(@io.string).to match(/^      a = "a"$/)
-      expect(@io.string).to match(/^      h2\.$/)
-      expect(@io.string).to match(/^        a = "b"$/)
-      expect(@io.string).to match(/^        h1\.$/)
-      expect(@io.string).to match(/^          a = "a"$/)
-      expect(@io.string).to match(/^          h2\.$/)
-      expect(@io.string).to match(/^            a = "b"$/)
-      expect(@io.string).to match(/^            h1\.$/)
-      expect(@io.string).to match(/^              a = "a"$/)
-      expect(@io.string).to match(/^              h2\.$/)
-      expect(@io.string).to match(/^                a = "b"$/)
-      expect(@io.string).to match(/^                h1\.$/)
-      expect(@io.string).to match(/^                  a = "a"$/)
-      expect(@io.string).to match(/^                  h2\.$/)
-      expect(@io.string).to match(/^                    a = "b"$/)
-      expect(@io.string).to match(/^                    h1\.$/)
-      expect(@io.string).to match(/^                      a = "a"$/)
-      expect(@io.string).to match(/^                      h2\.$/)
-      expect(@io.string).to match(/^                        \(recursion limit reached\)$/)
+    it 'has a simple way of display' do
+      io = StringIO.new
+      ros.debug_inspect(io)
+      expect(io.string).to match(/^a = "b"$/)
+      expect(io.string).to match(/^h1\.$/)
+      expect(io.string).to match(/^  a = "a"$/)
+      expect(io.string).to match(/^  h2\.$/)
+      expect(io.string).to match(/^    a = "b"$/)
+      expect(io.string).to match(/^    h1\.$/)
+      expect(io.string).to match(/^      a = "a"$/)
+      expect(io.string).to match(/^      h2\.$/)
+      expect(io.string).to match(/^        a = "b"$/)
+      expect(io.string).to match(/^        h1\.$/)
+      expect(io.string).to match(/^          a = "a"$/)
+      expect(io.string).to match(/^          h2\.$/)
+      expect(io.string).to match(/^            a = "b"$/)
+      expect(io.string).to match(/^            h1\.$/)
+      expect(io.string).to match(/^              a = "a"$/)
+      expect(io.string).to match(/^              h2\.$/)
+      expect(io.string).to match(/^                a = "b"$/)
+      expect(io.string).to match(/^                h1\.$/)
+      expect(io.string).to match(/^                  a = "a"$/)
+      expect(io.string).to match(/^                  h2\.$/)
+      expect(io.string).to match(/^                    a = "b"$/)
+      expect(io.string).to match(/^                    h1\.$/)
+      expect(io.string).to match(/^                      a = "a"$/)
+      expect(io.string).to match(/^                      h2\.$/)
+      expect(io.string).to match(/^                        \(recursion limit reached\)$/)
     end
   end
 end

spec/recursive_open_struct/indifferent_access_spec.rb

@@ -4,105 +4,111 @@
 require 'recursive_open_struct'
 
 describe RecursiveOpenStruct do
-  let(:value) { 'foo' }
-  let(:symbol) { :bar }
-  let(:new_value) { 'bar' }
-  let(:new_symbol) { :foo }
-
   describe 'indifferent access' do
-    let(:hash) { { :foo => value, 'bar' => symbol } }
+    subject(:hash_ros) { described_class.new(hash, hash_ros_opts) }
+
+    let(:hash) { { :foo => value, 'bar' => :bar } }
     let(:hash_ros_opts) { {} }
-    subject(:hash_ros) { RecursiveOpenStruct.new(hash, hash_ros_opts) }
 
-    context 'setting value with method' do
-      before(:each) do
-        subject.foo = value
+    describe 'setting value with method' do
+      let(:value) { 'foo' }
+
+      before do
+        hash_ros.foo = value
       end
 
-      it('allows getting with method') { expect(subject.foo).to be value }
-      it('allows getting with symbol') { expect(subject[:foo]).to be value }
-      it('allows getting with string') { expect(subject['foo']).to be value }
+      it('allows getting with method') { expect(hash_ros.foo).to be value }
+      it('allows getting with symbol') { expect(hash_ros[:foo]).to be value }
+      it('allows getting with string') { expect(hash_ros['foo']).to be value }
     end
 
-    context 'setting value with symbol' do
-      before(:each) do
-        subject[:foo] = value
+    describe 'setting value with symbol' do
+      let(:value) { 'foo' }
+
+      before do
+        hash_ros[:foo] = value
       end
 
-      it('allows getting with method') { expect(subject.foo).to be value }
-      it('allows getting with symbol') { expect(subject[:foo]).to be value }
-      it('allows getting with string') { expect(subject['foo']).to be value }
+      it('allows getting with method') { expect(hash_ros.foo).to be value }
+      it('allows getting with symbol') { expect(hash_ros[:foo]).to be value }
+      it('allows getting with string') { expect(hash_ros['foo']).to be value }
     end
 
-    context 'setting value with string' do
-      before(:each) do
-        subject['foo'] = value
+    describe 'setting value with string' do
+      let(:value) { 'foo' }
+
+      before do
+        hash_ros['foo'] = value
       end
 
-      it('allows getting with method') { expect(subject.foo).to be value }
-      it('allows getting with symbol') { expect(subject[:foo]).to be value }
-      it('allows getting with string') { expect(subject['foo']).to be value }
+      it('allows getting with method') { expect(hash_ros.foo).to be value }
+      it('allows getting with symbol') { expect(hash_ros[:foo]).to be value }
+      it('allows getting with string') { expect(hash_ros['foo']).to be value }
     end
 
-    context 'overwriting values' do
-      context 'set with method' do
-        before(:each) do
-          subject.foo = value
+    describe 'overwriting values' do
+      let(:value) { 'foo' }
+      let(:new_value) { 'bar' }
+
+      describe 'set with method' do
+        before do
+          hash_ros.foo = value
         end
 
         it('overrides with symbol') do
-          subject[:foo] = new_value
-          expect(subject.foo).to be new_value
+          hash_ros[:foo] = new_value
+          expect(hash_ros.foo).to be new_value
         end
 
         it('overrides with string') do
-          subject['foo'] = new_value
-          expect(subject.foo).to be new_value
+          hash_ros['foo'] = new_value
+          expect(hash_ros.foo).to be new_value
         end
       end
 
-      context 'set with symbol' do
-        before(:each) do
-          subject[:foo] = value
+      describe 'set with symbol' do
+        before do
+          hash_ros[:foo] = value
         end
 
         it('overrides with method') do
-          subject.foo = new_value
-          expect(subject[:foo]).to be new_value
+          hash_ros.foo = new_value
+          expect(hash_ros[:foo]).to be new_value
         end
 
         it('overrides with string') do
-          subject['foo'] = new_value
-          expect(subject[:foo]).to be new_value
+          hash_ros['foo'] = new_value
+          expect(hash_ros[:foo]).to be new_value
         end
       end
 
-      context 'set with string' do
-        before(:each) do
-          subject['foo'] = value
+      describe 'set with string' do
+        before do
+          hash_ros['foo'] = value
         end
 
         it('overrides with method') do
-          subject.foo = new_value
-          expect(subject['foo']).to be new_value
+          hash_ros.foo = new_value
+          expect(hash_ros['foo']).to be new_value
         end
 
         it('overrides with symbol') do
-          subject[:foo] = new_value
-          expect(subject['foo']).to be new_value
+          hash_ros[:foo] = new_value
+          expect(hash_ros['foo']).to be new_value
         end
       end
 
-      context 'set with hash' do
+      describe 'set with hash' do
         it('overrides with method') do
           hash_ros.foo = new_value
           expect(hash_ros[:foo]).to be new_value
-
+          new_symbol = :foo
           hash_ros.bar = new_symbol
           expect(hash_ros['bar']).to be new_symbol
         end
 
         it('overrides with symbol') do
+          new_symbol = :foo
           hash_ros[:bar] = new_symbol
           expect(hash_ros['bar']).to be new_symbol
         end
@@ -114,8 +120,10 @@
       end
 
       context 'when preserve_original_keys is not enabled' do
-        context 'transforms original keys to symbols' do
-          subject(:recursive) { RecursiveOpenStruct.new(recursive_hash, recurse_over_arrays: true) }
+        # rubocop:disable RSpec/MultipleMemoizedHelpers
+        describe 'transforms original keys to symbols' do
+          subject(:recursive) { described_class.new(recursive_hash, recurse_over_arrays: true) }
+
           let(:recursive_hash) { { foo: [{ 'bar' => [{ 'foo' => :bar }] }] } }
           let(:symbolized_recursive_hash) { { foo: [{ bar: [{ foo: :bar }] }] } }
           let(:symbolized_modified_hash) { { foo: [{ bar: [{ foo: :foo }] }] } }
@@ -134,13 +142,16 @@
             expect(recursive.to_h).to eq symbolized_modified_hash
           end
         end
+        # rubocop:enable RSpec/MultipleMemoizedHelpers
       end
 
       context 'when preserve_original_keys is enabled' do
-        context 'preserves the original keys' do
+        # rubocop:disable RSpec/MultipleMemoizedHelpers
+        describe 'preserves the original keys' do
           subject(:recursive) do
-            RecursiveOpenStruct.new(recursive_hash, recurse_over_arrays: true, preserve_original_keys: true)
+            described_class.new(recursive_hash, recurse_over_arrays: true, preserve_original_keys: true)
           end
+
           let(:recursive_hash) { { foo: [{ 'bar' => [{ 'foo' => :bar }] }] } }
           let(:modified_hash) { { foo: [{ 'bar' => [{ 'foo' => :foo }] }] } }
 
@@ -159,11 +170,13 @@
             expect(recursive.to_h).to eq modified_hash
           end
         end
+        # rubocop:enable RSpec/MultipleMemoizedHelpers
       end
 
       context 'when undefined method' do
         context 'when raise_on_missing is enabled' do
-          subject(:recursive) { RecursiveOpenStruct.new(recursive_hash, raise_on_missing: true) }
+          subject(:recursive) { described_class.new(recursive_hash, raise_on_missing: true) }
+
           let(:recursive_hash) { { foo: [{ 'bar' => [{ 'foo' => :bar }] }] } }
 
           specify 'raises NoMethodError' do
@@ -174,13 +187,12 @@
         end
 
         context 'when raise_on_missing is disabled' do
-          context 'preserves the original keys' do
-            subject(:recursive) { RecursiveOpenStruct.new(recursive_hash) }
-            let(:recursive_hash) { { foo: [{ 'bar' => [{ 'foo' => :bar }] }] } }
+          subject(:recursive) { described_class.new(recursive_hash) }
+
+          let(:recursive_hash) { { foo: [{ 'bar' => [{ 'foo' => :bar }] }] } }
 
-            specify 'returns nil' do
-              expect(recursive.undefined_method).to be_nil
-            end
+          specify 'returns nil' do
+            expect(recursive.undefined_method).to be_nil
           end
         end
       end