reek 1.3.8 → 1.4.0

data/spec/reek/core/module_context_spec.rb

@@ -6,22 +6,22 @@ include Reek::Core
 
 describe ModuleContext do
   it 'should report module name for smell in method' do
-    'module Fred; def simple(x) x + 1; end; end'.should reek_of(:UncommunicativeParameterName, /x/, /simple/)
+    expect('module Fred; def simple(x) x + 1; end; end').to reek_of(:UncommunicativeParameterName, /x/, /simple/)
   end
 
   it 'should not report module with empty class' do
-    '# module for test
+    expect('# module for test
 module Fred
 # module for test
- class Jim; end; end'.should_not reek
+ class Jim; end; end').not_to reek
   end
 end
 
 describe ModuleContext do
   it 'should recognise global constant' do
-    '# module for test
+    expect('# module for test
 module ::Global
 # module for test
- class Inside; end; end'.should_not reek
+ class Inside; end; end').not_to reek
   end
 end

data/spec/reek/core/object_refs_spec.rb

@@ -10,11 +10,11 @@ describe ObjectRefs do
 
   context 'when empty' do
     it 'should report no refs to self' do
-      @refs.references_to(:self).should == 0
+      expect(@refs.references_to(:self)).to eq(0)
     end
   end
 
-  context "with references to a, b, and a" do
+  context 'with references to a, b, and a' do
     context 'with no refs to self' do
       before(:each) do
         @refs.record_reference_to('a')
@@ -23,33 +23,33 @@ describe ObjectRefs do
       end
 
       it 'should report no refs to self' do
-        @refs.references_to(:self).should == 0
+        expect(@refs.references_to(:self)).to eq(0)
       end
 
       it 'should report :a as the max' do
-        @refs.max_keys.should == {'a' => 2}
+        expect(@refs.max_keys).to eq('a' => 2)
       end
 
       it 'should not report self as the max' do
-        @refs.self_is_max?.should == false
+        expect(@refs.self_is_max?).to eq(false)
       end
 
-      context "with one reference to self" do
+      context 'with one reference to self' do
         before(:each) do
           @refs.record_reference_to(:self)
         end
 
         it 'should report 1 ref to self' do
-          @refs.references_to(:self).should == 1
+          expect(@refs.references_to(:self)).to eq(1)
         end
 
         it 'should not report self among the max' do
-          @refs.max_keys.should include('a')
-          @refs.max_keys.should_not include(:self)
+          expect(@refs.max_keys).to include('a')
+          expect(@refs.max_keys).not_to include(:self)
         end
 
         it 'should not report self as the max' do
-          @refs.self_is_max?.should == false
+          expect(@refs.self_is_max?).to eq(false)
         end
       end
     end
@@ -67,15 +67,15 @@ describe ObjectRefs do
     end
 
     it 'should report all refs to self' do
-      @refs.references_to(:self).should == 4
+      expect(@refs.references_to(:self)).to eq(4)
     end
 
     it 'should report self among the max' do
-      @refs.max_keys.should == { :self => 4}
+      expect(@refs.max_keys).to eq(self: 4)
     end
 
     it 'should report self as the max' do
-      @refs.self_is_max?.should == true
+      expect(@refs.self_is_max?).to eq(true)
     end
   end
 
@@ -89,16 +89,16 @@ describe ObjectRefs do
     end
 
     it 'should report all refs to self' do
-      @refs.references_to(:self).should == 2
+      expect(@refs.references_to(:self)).to eq(2)
     end
 
     it 'should report self among the max' do
-      @refs.max_keys.should include('a')
-      @refs.max_keys.should include(:self)
+      expect(@refs.max_keys).to include('a')
+      expect(@refs.max_keys).to include(:self)
     end
 
     it 'should report self as the max' do
-      @refs.self_is_max?.should == true
+      expect(@refs.self_is_max?).to eq(true)
     end
   end
 
@@ -111,17 +111,16 @@ describe ObjectRefs do
     end
 
     it 'should report all refs to self' do
-      @refs.references_to(:self).should == 0
+      expect(@refs.references_to(:self)).to eq(0)
     end
 
     it 'should not report self among the max' do
-      @refs.max_keys.should include('a')
-      @refs.max_keys.should include('b')
+      expect(@refs.max_keys).to include('a')
+      expect(@refs.max_keys).to include('b')
     end
 
     it 'should not report self as the max' do
-      @refs.self_is_max?.should == false
+      expect(@refs.self_is_max?).to eq(false)
     end
   end
 end
-

data/spec/reek/core/smell_configuration_spec.rb

@@ -6,42 +6,43 @@ include Reek::Core
 describe SmellConfiguration do
   it 'returns the default value when key not found' do
     cf = SmellConfiguration.new({})
-    cf.value('fred', nil, 27).should == 27
+    expect(cf.value('fred', nil, 27)).to eq(27)
   end
 
   context 'when overriding default configs' do
     before(:each) do
-      @base_config = {"enabled"=>true, "exclude"=>[],
-                      "reject"=>[/^.$/, /[0-9]$/, /[A-Z]/],
-                      "accept"=>["_"]}
+      @base_config = { 'enabled' => true, 'exclude' => [],
+                      'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
+                      'accept' => ['_'] }
       @smell_config = SmellConfiguration.new(@base_config)
     end
 
-    it { @smell_config.merge!({}).should == @base_config }
-    it { @smell_config.merge!({"enabled"=>true}).should == @base_config }
-    it { @smell_config.merge!({"exclude"=>[]}).should == @base_config }
-    it { @smell_config.merge!({"accept"=>["_"]}).should == @base_config }
-    it { @smell_config.merge!({"reject"=>[/^.$/, /[0-9]$/, /[A-Z]/]}).should == @base_config }
-    it { @smell_config.merge!({"enabled"=>true, "accept"=>["_"]}).should == @base_config }
+    it { expect(@smell_config.merge!({})).to eq(@base_config) }
+    it { expect(@smell_config.merge!('enabled' => true)).to eq(@base_config) }
+    it { expect(@smell_config.merge!('exclude' => [])).to eq(@base_config) }
+    it { expect(@smell_config.merge!('accept' => ['_'])).to eq(@base_config) }
+    it { expect(@smell_config.merge!('reject' => [/^.$/, /[0-9]$/, /[A-Z]/])).to eq(@base_config) }
+    it { expect(@smell_config.merge!('enabled' => true, 'accept' => ['_'])).to eq(@base_config) }
 
     it 'should override single values' do
-      @smell_config.merge!({"enabled"=>false}).should == {"enabled"=>false, "exclude"=>[],
-                                                          "reject"=>[/^.$/, /[0-9]$/, /[A-Z]/],
-                                                          "accept"=>["_"]}
+      expect(@smell_config.merge!('enabled' => false)).to eq('enabled' => false, 'exclude' => [],
+                                                          'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
+                                                          'accept' => ['_'])
     end
 
     it 'should override arrays of values' do
-      @smell_config.merge!({"reject"=>[/^.$/, /[3-9]$/]}).should == {"enabled"=>true,
-                                                          "exclude"=>[],
-                                                          "reject"=>[/^.$/, /[3-9]$/],
-                                                          "accept"=>["_"]}
+      expect(@smell_config.merge!('reject' => [/^.$/, /[3-9]$/])).to eq('enabled' => true,
+                                                                        'exclude' => [],
+                                                                        'reject' => [/^.$/, /[3-9]$/],
+                                                                        'accept' => ['_'])
     end
 
     it 'should override multiple values' do
-      @smell_config.merge!({"enabled"=>false, "accept"=>[/[A-Z]$/]}).should ==
-                           {"enabled"=>false, "exclude"=>[],
-                            "reject"=>[/^.$/, /[0-9]$/, /[A-Z]/],
-                            "accept"=>[/[A-Z]$/]}
+      expect(@smell_config.merge!('enabled' => false, 'accept' => [/[A-Z]$/])).to eq(
+                           'enabled' => false, 'exclude' => [],
+                            'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
+                            'accept' => [/[A-Z]$/]
+      )
     end
   end
 end

data/spec/reek/core/stop_context_spec.rb

@@ -10,8 +10,8 @@ describe StopContext do
   end
 
   context 'full_name' do
-    it "reports full context" do
-      @stop.full_name.should == ''
+    it 'reports full context' do
+      expect(@stop.full_name).to eq('')
     end
   end
 end

data/spec/reek/core/warning_collector_spec.rb

@@ -11,17 +11,17 @@ describe WarningCollector do
 
   context 'when empty' do
     it 'reports no warnings' do
-      @collector.warnings.should == []
+      expect(@collector.warnings).to eq([])
     end
   end
 
   context 'with one warning' do
     before :each do
-      @warning = Reek::SmellWarning.new('ControlCouple', 'fred', [1,2,3], 'hello')
+      @warning = Reek::SmellWarning.new('ControlCouple', 'fred', [1, 2, 3], 'hello')
       @collector.found_smell(@warning)
     end
     it 'reports that warning' do
-      @collector.warnings.should == [@warning]
+      expect(@collector.warnings).to eq([@warning])
     end
   end
 end

data/spec/reek/examiner_spec.rb

@@ -5,25 +5,25 @@ include Reek
 
 shared_examples_for 'supports the deprecated api' do
   it 'returns all smells as active' do
-    @examiner.all_active_smells.should == @examiner.smells
+    expect(@examiner.all_active_smells).to eq(@examiner.smells)
   end
   it 'returns all smells as active' do
-    @examiner.all_smells.should == @examiner.smells
+    expect(@examiner.all_smells).to eq(@examiner.smells)
   end
   it 'counts all smells as active smells' do
-    @examiner.num_active_smells.should == @examiner.smells.length
+    expect(@examiner.num_active_smells).to eq(@examiner.smells.length)
   end
   it 'never reports masked smells' do
-    @examiner.num_masked_smells.should == 0
+    expect(@examiner.num_masked_smells).to eq(0)
   end
 end
 
 shared_examples_for 'no smells found' do
   it 'is not smelly' do
-    @examiner.should_not be_smelly
+    expect(@examiner).not_to be_smelly
   end
   it 'finds no smells' do
-    @examiner.smells.length.should == 0
+    expect(@examiner.smells.length).to eq(0)
   end
 
   it_should_behave_like 'supports the deprecated api'
@@ -31,13 +31,13 @@ end
 
 shared_examples_for 'one smell found' do
   it 'is smelly' do
-    @examiner.should be_smelly
+    expect(@examiner).to be_smelly
   end
   it 'reports the smell' do
-    @examiner.smells.length.should == 1
+    expect(@examiner.smells.length).to eq(1)
   end
   it 'reports the correct smell' do
-    @examiner.smells[0].smell_class.should == @expected_first_smell
+    expect(@examiner.smells[0].smell_class).to eq(@expected_first_smell)
   end
 
   it_should_behave_like 'supports the deprecated api'

data/spec/reek/smell_warning_spec.rb

@@ -7,24 +7,24 @@ describe SmellWarning do
   context 'sort order' do
     shared_examples_for 'first sorts ahead of second' do
       it 'hash differently' do
-        @first.hash.should_not == @second.hash
+        expect(@first.hash).not_to eq(@second.hash)
       end
       it 'are not equal' do
-        @first.should_not == @second
+        expect(@first).not_to eq(@second)
       end
       it 'sort correctly' do
-        (@first <=> @second).should be < 0
+        expect(@first <=> @second).to be < 0
       end
       it 'does not match using eql?' do
-        @first.should_not eql(@second)
-        @second.should_not eql(@first)
+        expect(@first).not_to eql(@second)
+        expect(@second).not_to eql(@first)
       end
     end
 
     context 'smells differing only by detector' do
       before :each do
-        @first = SmellWarning.new('Duplication', "self", 27, "self", false)
-        @second = SmellWarning.new('FeatureEnvy', "self", 27, "self", true)
+        @first = SmellWarning.new('Duplication', 'self', 27, 'self', false)
+        @second = SmellWarning.new('FeatureEnvy', 'self', 27, 'self', true)
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -32,8 +32,8 @@ describe SmellWarning do
 
     context 'smells differing only by context' do
       before :each do
-        @first = SmellWarning.new('FeatureEnvy', "first", 27, "self", true)
-        @second = SmellWarning.new('FeatureEnvy', "second", 27, "self", false)
+        @first = SmellWarning.new('FeatureEnvy', 'first', 27, 'self', true)
+        @second = SmellWarning.new('FeatureEnvy', 'second', 27, 'self', false)
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -41,8 +41,8 @@ describe SmellWarning do
 
     context 'smells differing only by message' do
       before :each do
-        @first = SmellWarning.new('FeatureEnvy', "context", 27, "first", true)
-        @second = SmellWarning.new('FeatureEnvy', "context", 27, "second", false)
+        @first = SmellWarning.new('FeatureEnvy', 'context', 27, 'first', true)
+        @second = SmellWarning.new('FeatureEnvy', 'context', 27, 'second', false)
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -50,8 +50,8 @@ describe SmellWarning do
 
     context 'message takes precedence over smell name' do
       before :each do
-        @first = SmellWarning.new('UtilityFunction', "context", 27, "first", true)
-        @second = SmellWarning.new('FeatureEnvy', "context", 27, "second", false)
+        @first = SmellWarning.new('UtilityFunction', 'context', 27, 'first', true)
+        @second = SmellWarning.new('FeatureEnvy', 'context', 27, 'second', false)
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -59,8 +59,8 @@ describe SmellWarning do
 
     context 'smells differing everywhere' do
       before :each do
-        @first = SmellWarning.new('UncommunicativeName', "Dirty", 27, "has the variable name '@s'", true)
-        @second = SmellWarning.new('Duplication', 'Dirty#a', 27, "calls @s.title twice", false)
+        @first = SmellWarning.new('UncommunicativeName', 'Dirty', 27, "has the variable name '@s'", true)
+        @second = SmellWarning.new('Duplication', 'Dirty#a', 27, 'calls @s.title twice', false)
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -78,20 +78,20 @@ describe SmellWarning do
 
     shared_examples_for 'common fields' do
       it 'includes the smell class' do
-        @yaml.should match(/class:\s*FeatureEnvy/)
+        expect(@yaml).to match(/class:\s*FeatureEnvy/)
       end
       it 'includes the context' do
-        @yaml.should match(/context:\s*#{@context_name}/)
+        expect(@yaml).to match(/context:\s*#{@context_name}/)
       end
       it 'includes the message' do
-        @yaml.should match(/message:\s*#{@message}/)
+        expect(@yaml).to match(/message:\s*#{@message}/)
       end
       it 'indicates the masking' do
-        @yaml.should match(/is_active:\s*true/)
+        expect(@yaml).to match(/is_active:\s*true/)
       end
       it 'includes the line numbers' do
         @lines.each do |line|
-          @yaml.should match(/lines:[\s\d-]*- #{line}/)
+          expect(@yaml).to match(/lines:[\s\d-]*- #{line}/)
         end
       end
     end
@@ -100,23 +100,23 @@ describe SmellWarning do
       before :each do
         @source = 'a/ruby/source/file.rb'
         @subclass = 'TooManyParties'
-        @parameters = {'one' => 34, 'two' => 'second'}
+        @parameters = { 'one' => 34, 'two' => 'second' }
         @warning = SmellWarning.new(@class, @context_name, @lines, @message,
-          @source, @subclass, @parameters)
+                                    @source, @subclass, @parameters)
         @yaml = @warning.to_yaml
       end
 
       it_should_behave_like 'common fields'
 
       it 'includes the subclass' do
-        @yaml.should match(/subclass:\s*#{@subclass}/)
+        expect(@yaml).to match(/subclass:\s*#{@subclass}/)
       end
       it 'includes the source' do
-        @yaml.should match(/source:\s*#{@source}/)
+        expect(@yaml).to match(/source:\s*#{@source}/)
       end
       it 'includes the parameters' do
-        @parameters.each do |key,value|
-          @yaml.should match(/#{key}:\s*#{value}/)
+        @parameters.each do |key, value|
+          expect(@yaml).to match(/#{key}:\s*#{value}/)
         end
       end
     end
@@ -130,13 +130,13 @@ describe SmellWarning do
       it_should_behave_like 'common fields'
 
       it 'includes no subclass' do
-        @yaml.should match(/subclass: ["']{2}/)
+        expect(@yaml).to match(/subclass: ["']{2}/)
       end
       it 'includes no source' do
-        @yaml.should match(/source: ["']{2}/)
+        expect(@yaml).to match(/source: ["']{2}/)
       end
       it 'includes empty parameters' do
-        @yaml.should_not match(/parameter/)
+        expect(@yaml).not_to match(/parameter/)
       end
     end
   end

data/spec/reek/smells/attribute_spec.rb

@@ -18,7 +18,7 @@ describe Attribute do
     it 'records nothing in the module' do
       src = 'module Fred; end'
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-      @detector.examine_context(ctx).should be_empty
+      expect(@detector.examine_context(ctx)).to be_empty
     end
   end
 
@@ -34,19 +34,19 @@ describe Attribute do
       end
 
       it 'records only that attribute' do
-        @smells.length.should == 1
+        expect(@smells.length).to eq(1)
       end
       it 'reports the attribute name' do
-        @smells[0].smell[Attribute::ATTRIBUTE_KEY].should == @attr_name
+        expect(@smells[0].smell[Attribute::ATTRIBUTE_KEY]).to eq(@attr_name)
       end
       it 'reports the declaration line number' do
-        @smells[0].lines.should == [1]
+        expect(@smells[0].lines).to eq([1])
       end
       it 'reports the correct smell class' do
-        @smells[0].smell_class.should == Attribute::SMELL_CLASS
+        expect(@smells[0].smell_class).to eq(Attribute::SMELL_CLASS)
       end
       it 'reports the context fq name' do
-        @smells[0].context.should == 'Fred'
+        expect(@smells[0].context).to eq('Fred')
       end
     end