reek 1.5.1 → 1.6.0

data/spec/reek/smells/long_yield_list_spec.rb

@@ -26,7 +26,7 @@ describe LongYieldList do
     end
     it 'should report yield with many parameters' do
       src = 'def simple(arga, argb, &blk) f(3);yield arga,argb,arga,argb; end'
-      expect(src).to smell_of(LongYieldList, LongYieldList::PARAMETER_COUNT_KEY => 4)
+      expect(src).to smell_of(LongYieldList, count: 4)
     end
     it 'should not report yield of a long expression' do
       src = 'def simple(arga, argb, &blk) f(3);yield(if @dec then argb else 5+3 end); end'
@@ -50,7 +50,7 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the correct values' do
-      expect(@warning.smell['parameter_count']).to eq(4)
+      expect(@warning.parameters[:count]).to eq(4)
       expect(@warning.lines).to eq([3])
     end
   end

data/spec/reek/smells/module_initialize_spec.rb

@@ -16,5 +16,31 @@ describe ModuleInitialize do
         expect(src).to smell_of(ModuleInitialize)
       end
     end
+
+    context 'with method named initialize in a nested class' do
+      it 'does not smell' do
+        src = <<-EOF
+          module A
+            class B
+              def initialize; end
+            end
+          end
+        EOF
+        expect(src).not_to smell_of(ModuleInitialize)
+      end
+    end
+
+    context 'with method named initialize in a nested struct' do
+      it 'does not smell' do
+        src = <<-EOF
+          module A
+            B = Struct.new(:c) do
+              def initialize; end
+            end
+          end
+        EOF
+        expect(src).not_to smell_of(ModuleInitialize)
+      end
+    end
   end
 end

data/spec/reek/smells/nested_iterators_spec.rb

@@ -5,7 +5,6 @@ require 'reek/smells/smell_detector_shared'
 include Reek::Smells
 
 describe NestedIterators do
-
   context 'with no iterators' do
     it 'reports no smells' do
       src = 'def fred() nothing = true; end'
@@ -85,7 +84,7 @@ EOS
         ) { |qux| qux.quuz }
       end
     EOS
-    expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2)
+    expect(src).to smell_of(NestedIterators, count: 2)
   end
 
   it 'reports the deepest level of nesting only' do
@@ -98,7 +97,7 @@ EOS
         }
       end
     EOS
-    expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 3)
+    expect(src).to smell_of(NestedIterators, count: 3)
   end
 
   context 'when the allowed nesting depth is 3' do
@@ -150,18 +149,30 @@ EOS
     end
 
     it 'should report nested iterators inside the ignored iterator' do
-      src = 'def bad(fred) @fred.ignore_me {|item| item.each {|ting| ting.each {|other| other.other} } } end'
-      expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+      src = '
+        def bad(fred)
+          @fred.ignore_me {|item| item.each {|ting| ting.each {|other| other.other} } }
+        end
+      '
+      expect(src).to smell_of(NestedIterators, count: 2).with_config(@config)
     end
 
     it 'should report nested iterators outside the ignored iterator' do
-      src = 'def bad(fred) @fred.each {|item| item.each {|ting| ting.ignore_me {|other| other.other} } } end'
-      expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+      src = '
+        def bad(fred)
+          @fred.each {|item| item.each {|ting| ting.ignore_me {|other| other.other} } }
+        end
+      '
+      expect(src).to smell_of(NestedIterators, count: 2).with_config(@config)
     end
 
     it 'should report nested iterators with the ignored iterator between them' do
-      src = 'def bad(fred) @fred.each {|item| item.ignore_me {|ting| ting.ting {|other| other.other} } } end'
-      expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+      src = '
+        def bad(fred)
+          @fred.each {|item| item.ignore_me {|ting| ting.ting {|other| other.other} } }
+        end
+      '
+      expect(src).to smell_of(NestedIterators, count: 2).with_config(@config)
     end
   end
 end
@@ -190,7 +201,7 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports correct values' do
-      expect(@warning.smell[NestedIterators::NESTING_DEPTH_KEY]).to eq(2)
+      expect(@warning.parameters[:count]).to eq(2)
       expect(@warning.lines).to eq([3])
     end
   end

data/spec/reek/smells/nil_check_spec.rb

@@ -6,9 +6,7 @@ include Reek
 include Reek::Smells
 
 describe NilCheck do
-
   context 'for methods' do
-
     it 'reports the correct line number' do
       src = <<-EOS
       def nilcheck foo

data/spec/reek/smells/prima_donna_method_spec.rb

@@ -17,14 +17,14 @@ describe PrimaDonnaMethod do
   describe 'the right smell' do
     let(:detector) { PrimaDonnaMethod.new('dummy_source') }
     let(:src)      { 'class C; def m!; end; end' }
-    let(:ctx)      { CodeContext.new(nil, src.to_reek_source.syntax_tree) }
+    let(:ctx)      { ModuleContext.new(nil, src.to_reek_source.syntax_tree) }
 
     it 'should be reported' do
       smells = detector.examine_context(ctx)
       warning = smells[0]
 
-      expect(warning.smell_class).to eq('PrimaDonnaMethod')
-      expect(warning.subclass).to eq('PrimaDonnaMethod')
+      expect(warning.smell_category).to eq('PrimaDonnaMethod')
+      expect(warning.smell_type).to eq('PrimaDonnaMethod')
       expect(warning.lines).to eq([1])
     end
   end

data/spec/reek/smells/repeated_conditional_spec.rb

@@ -75,32 +75,6 @@ EOS
     it 'knows there are three copies' do
       expect(@conds.values[1].length).to eq(3)
     end
-
-    context 'looking at the YAML' do
-      before :each do
-        @detector.examine(@ctx)
-        warning = @detector.smells_found.to_a[0]   # SMELL: too cumbersome!
-        @yaml = warning.to_yaml
-      end
-      it 'reports the source' do
-        expect(@yaml).to match(/source:\s*#{@source_name}/)
-      end
-      it 'reports the class' do
-        expect(@yaml).to match(/class:\s*SimulatedPolymorphism/)
-      end
-      it 'reports the subclass' do
-        expect(@yaml).to match(/subclass:\s*RepeatedConditional/)
-      end
-      it 'reports the expression' do
-        expect(@yaml).to match(/expression:\s*(! )?['"]?#{@cond}["']?/)
-      end
-      it 'reports the number of occurrences' do
-        expect(@yaml).to match(/occurrences:\s*3/)
-      end
-      it 'reports the referring lines' do
-        expect(@yaml).to match(/lines:\s*- 4\s*- 7\s*- 12/)
-      end
-    end
   end
 
   context 'with a matching if and case' do

data/spec/reek/smells/smell_detector_shared.rb

@@ -32,10 +32,10 @@ shared_examples_for 'common fields set correctly' do
   it 'reports the source' do
     expect(@warning.source).to eq(@source_name)
   end
-  it 'reports the class' do
-    expect(@warning.smell_class).to eq(@detector.class::SMELL_CLASS)
+  it 'reports the smell class' do
+    expect(@warning.smell_category).to eq(@detector.smell_category)
   end
-  it 'reports the subclass' do
-    expect(@warning.subclass).to eq(@detector.class::SMELL_SUBCLASS)
+  it 'reports the smell sub class' do
+    expect(@warning.smell_type).to eq(@detector.smell_type)
   end
 end

data/spec/reek/smells/too_many_instance_variables_spec.rb

@@ -80,9 +80,9 @@ describe TooManyInstanceVariables do
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
     expect(@warning.source).to eq(@source_name)
-    expect(@warning.smell_class).to eq('LargeClass')
-    expect(@warning.subclass).to eq(TooManyInstanceVariables::SMELL_SUBCLASS)
-    expect(@warning.smell[TooManyInstanceVariables::IVAR_COUNT_KEY]).to eq(10)
+    expect(@warning.smell_category).to eq(TooManyInstanceVariables.smell_category)
+    expect(@warning.smell_type).to eq(TooManyInstanceVariables.smell_type)
+    expect(@warning.parameters[:count]).to eq(10)
     expect(@warning.lines).to eq([2])
   end
 end

data/spec/reek/smells/too_many_methods_spec.rb

@@ -16,7 +16,6 @@ describe TooManyMethods do
   it_should_behave_like 'SmellDetector'
 
   context 'counting methods' do
-
     it 'should not report 25 methods' do
       src = <<EOS
 # smelly class for testing purposes
@@ -28,7 +27,7 @@ class Full
   def me41x()3 end;def me42x()3 end;def me43x()3 end;def me44x()3 end;def me45x()3 end
 end
 EOS
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = ModuleContext.new(nil, src.to_reek_source.syntax_tree)
       expect(@detector.examine_context(ctx)).to be_empty
     end
 
@@ -43,11 +42,11 @@ class Full
   def me51x()3 end
 end
 EOS
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = ModuleContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       expect(smells.length).to eq(1)
-      expect(smells[0].subclass).to eq(TooManyMethods::SMELL_SUBCLASS)
-      expect(smells[0].smell[TooManyMethods::METHOD_COUNT_KEY]).to eq(26)
+      expect(smells[0].smell_type).to eq(TooManyMethods.smell_type)
+      expect(smells[0].parameters[:count]).to eq(26)
     end
   end
 
@@ -59,11 +58,17 @@ class Full
   def me11x()3 end;def me12x()3 end;def me13x()3 end;def me14x()3 end;def me15x()3 end
   def me21x()3 end;def me22x()3 end;def me23x()3 end;def me24x()3 end;def me25x()3 end
   def me31x()3 end;def me32x()3 end;def me33x()3 end;def me34x()3 end;def me35x()3 end
-  module Hidden; def me41x()3 end;def me42x()3 end;def me43x()3 end;def me44x()3 end;def me45x()3 end; end
+  module Hidden
+    def me41x()3 end
+    def me42x()3 end
+    def me43x()3 end
+    def me44x()3 end
+    def me45x()3 end
+  end
   def me51x()3 end
 end
 EOS
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = ModuleContext.new(nil, src.to_reek_source.syntax_tree)
       expect(@detector.examine_context(ctx)).to be_empty
     end
   end
@@ -79,12 +84,12 @@ class Full
   def me51x()3 end
 end
 EOS
-    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    ctx = ModuleContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
     expect(@warning.source).to eq(@source_name)
-    expect(@warning.smell_class).to eq('LargeClass')
-    expect(@warning.subclass).to eq(TooManyMethods::SMELL_SUBCLASS)
-    expect(@warning.smell[TooManyMethods::METHOD_COUNT_KEY]).to eq(26)
+    expect(@warning.smell_category).to eq(TooManyMethods.smell_category)
+    expect(@warning.smell_type).to eq(TooManyMethods.smell_type)
+    expect(@warning.parameters[:count]).to eq(26)
     expect(@warning.lines).to eq([1])
   end
 end

data/spec/reek/smells/too_many_statements_spec.rb

@@ -31,7 +31,11 @@ describe TooManyStatements do
   end
 
   it 'should not report initialize' do
-    src = 'def initialize(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'
+    src = '
+      def initialize(arga)
+        alf = f(1); @bet = 2; @cut = 3; @dit = 4; @emp = 5; @fry = 6
+      end
+    '
     expect(src).not_to smell_of(TooManyStatements)
   end
 
@@ -134,7 +138,15 @@ describe TooManyStatements, 'does not count control statements' do
   end
 
   it 'counts 3 statements in an else' do
-    method = process_method('def one() if val == 4; callee(); callee(); callee(); else; callee(); callee(); callee(); end; end')
+    method = process_method('
+      def one()
+        if val == 4
+          callee(); callee(); callee()
+        else
+          callee(); callee(); callee()
+        end
+      end
+    ')
     expect(method.num_statements).to eq(6)
   end
 
@@ -159,8 +171,8 @@ describe TooManyStatements, 'does not count control statements' do
   end
 
   it 'counts 3 statements in a while loop' do
-    method = process_method('def one() while val < 4; callee(); callee(); callee(); end; end')
-    expect(method.num_statements).to eq(3)
+    source = 'def one() while val < 4; callee(); callee(); callee(); end; end'
+    expect(process_method(source).num_statements).to eq(3)
   end
 
   it 'counts extra statements in a while condition' do
@@ -174,8 +186,8 @@ describe TooManyStatements, 'does not count control statements' do
   end
 
   it 'counts 3 statements in a until loop' do
-    method = process_method('def one() until val < 4; callee(); callee(); callee(); end; end')
-    expect(method.num_statements).to eq(3)
+    source = 'def one() until val < 4; callee(); callee(); callee(); end; end'
+    expect(process_method(source).num_statements).to eq(3)
   end
 
   it 'counts 1 statement in a for loop' do
@@ -184,8 +196,8 @@ describe TooManyStatements, 'does not count control statements' do
   end
 
   it 'counts 3 statements in a for loop' do
-    method = process_method('def one() for i in 0..4; callee(); callee(); callee(); end; end')
-    expect(method.num_statements).to eq(3)
+    source = 'def one() for i in 0..4; callee(); callee(); callee(); end; end'
+    expect(process_method(source).num_statements).to eq(3)
   end
 
   it 'counts 1 statement in a rescue' do
@@ -194,7 +206,15 @@ describe TooManyStatements, 'does not count control statements' do
   end
 
   it 'counts 3 statements in a rescue' do
-    method = process_method('def one() begin; callee(); callee(); callee(); rescue; callee(); callee(); callee(); end; end')
+    method = process_method('
+      def one()
+        begin
+          callee(); callee(); callee()
+        rescue
+          callee(); callee(); callee()
+        end
+      end
+    ')
     expect(method.num_statements).to eq(6)
   end
 
@@ -204,17 +224,31 @@ describe TooManyStatements, 'does not count control statements' do
   end
 
   it 'counts 3 statements in a when' do
-    method = process_method('def one() case fred; when "hi"; callee(); callee(); when "lo"; callee(); end; end')
+    method = process_method('
+      def one()
+        case fred
+        when "hi" then callee(); callee()
+        when "lo" then callee()
+        end
+      end
+    ')
     expect(method.num_statements).to eq(3)
   end
 
   it 'counts 1 statement in a case else' do
-    method = process_method('def one() case fred; when "hi"; callee(); else; callee(); end; end')
-    expect(method.num_statements).to eq(2)
+    source = 'def one() case fred; when "hi"; callee(); else; callee(); end; end'
+    expect(process_method(source).num_statements).to eq(2)
   end
 
   it 'counts 3 statements in a case else' do
-    method = process_method('def one() case fred; when "hi"; callee(); callee(); callee(); else; callee(); callee(); callee(); end; end')
+    method = process_method('
+      def one()
+        case fred
+        when "hi" then callee(); callee(); callee()
+        else           callee(); callee(); callee()
+        end
+      end
+    ')
     expect(method.num_statements).to eq(6)
   end
 
@@ -234,8 +268,8 @@ describe TooManyStatements, 'does not count control statements' do
   end
 
   it 'counts 4 statements in an iterator' do
-    method = process_method('def one() fred.each do; callee(); callee(); callee(); end; end')
-    expect(method.num_statements).to eq(4)
+    source = 'def one() fred.each do; callee(); callee(); callee(); end; end'
+    expect(process_method(source).num_statements).to eq(4)
   end
 
   it 'counts 1 statement in a singleton method' do
@@ -259,14 +293,17 @@ describe TooManyStatements do
       expect(ctx).to receive(:config_for).with(TooManyStatements).and_return({})
       @smells = @detector.examine_context(ctx)
     end
+
     it 'reports only 1 smell' do
       expect(@smells.length).to eq(1)
     end
+
     it 'reports the number of statements' do
-      expect(@smells[0].smell[TooManyStatements::STATEMENT_COUNT_KEY]).to eq(@num_statements)
+      expect(@smells[0].parameters[:count]).to eq(@num_statements)
     end
-    it 'reports the correct subclass' do
-      expect(@smells[0].subclass).to eq(TooManyStatements::SMELL_SUBCLASS)
+
+    it 'reports the correct smell sub class' do
+      expect(@smells[0].smell_type).to eq(TooManyStatements.smell_type)
     end
   end
 end

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -17,7 +17,8 @@ describe UncommunicativeMethodName do
 
   ['help', '+', '-', '/', '*'].each do |method_name|
     it "accepts the method name '#{method_name}'" do
-      expect("def #{method_name}(fred) basics(17) end").not_to smell_of(UncommunicativeMethodName)
+      src = "def #{method_name}(fred) basics(17) end"
+      expect(src).not_to smell_of(UncommunicativeMethodName)
     end
   end
 
@@ -33,7 +34,7 @@ describe UncommunicativeMethodName do
       it_should_behave_like 'common fields set correctly'
 
       it 'reports the correct values' do
-        expect(@warning.smell[UncommunicativeMethodName::METHOD_NAME_KEY]).to eq(method_name)
+        expect(@warning.parameters[:name]).to eq(method_name)
         expect(@warning.lines).to eq([1])
         expect(@warning.context).to eq(method_name)
       end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -33,10 +33,10 @@ describe UncommunicativeModuleName do
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       expect(smells.length).to eq(1)
-      expect(smells[0].smell_class).to eq(UncommunicativeModuleName::SMELL_CLASS)
-      expect(smells[0].subclass).to eq(UncommunicativeModuleName::SMELL_SUBCLASS)
-      expect(smells[0].smell[UncommunicativeModuleName::MODULE_NAME_KEY]).to eq('X')
-      expect(smells[0].context).to match(/#{smells[0].smell[UncommunicativeModuleName::MODULE_NAME_KEY]}/)
+      expect(smells[0].smell_category).to eq(UncommunicativeModuleName.smell_category)
+      expect(smells[0].smell_type).to eq(UncommunicativeModuleName.smell_type)
+      expect(smells[0].parameters[:name]).to eq('X')
+      expect(smells[0].context).to match(/#{smells[0].parameters[:name]}/)
     end
   end
 
@@ -59,7 +59,7 @@ describe UncommunicativeModuleName do
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the correct values' do
-      expect(@warning.smell[UncommunicativeModuleName::MODULE_NAME_KEY]).to eq('Printer2')
+      expect(@warning.parameters[:name]).to eq('Printer2')
       expect(@warning.lines).to eq([1])
     end
   end