reek 1.4.0 → 1.5.0

data/spec/reek/smell_warning_spec.rb

@@ -86,9 +86,6 @@ describe SmellWarning do
       it 'includes the message' do
         expect(@yaml).to match(/message:\s*#{@message}/)
       end
-      it 'indicates the masking' do
-        expect(@yaml).to match(/is_active:\s*true/)
-      end
       it 'includes the line numbers' do
         @lines.each do |line|
           expect(@yaml).to match(/lines:[\s\d-]*- #{line}/)

data/spec/reek/smells/control_parameter_spec.rb

@@ -140,6 +140,30 @@ describe ControlParameter do
       src = 'def simple(arg) if arg != :foo then :bar else :foo end end'
       expect(src).to smell_of(ControlParameter)
     end
+
+    it 'reports when the argument is compared to a regexp' do
+      src = 'def simple(arg) if arg =~ /foo/ then :foo else :bar end end'
+      expect(src).to smell_of(ControlParameter)
+    end
+
+    it 'reports when the argument is reverse-compared to a regexp' do
+      src = 'def simple(arg) if /foo/ =~ arg then :foo else :bar end end'
+      expect(src).to smell_of(ControlParameter)
+    end
+
+    it 'reports when the argument is used in a complex regexp' do
+      src = 'def simple(arg) if /foo#{arg}/ =~ bar then :foo else :bar end end'
+      expect(src).to smell_of(ControlParameter)
+    end
+
+    it 'reports when the argument is a block parameter' do
+      src = <<-EOS
+        def foo &blk
+          bar(blk || proc {})
+        end
+      EOS
+      expect(src).to smell_of(ControlParameter)
+    end
   end
 
   context 'parameter used besides determining code path' do

data/spec/reek/smells/feature_envy_spec.rb

@@ -8,40 +8,43 @@ include Reek::Smells
 describe FeatureEnvy do
   context 'with no smell' do
     it 'should not report use of self' do
-      expect('def simple() self.to_s + self.to_i end').not_to reek
+      expect('def simple() self.to_s + self.to_i end').not_to reek_of(:FeatureEnvy)
     end
     it 'should not report vcall with no argument' do
-      expect('def simple() func; end').not_to reek
+      expect('def simple() func; end').not_to reek_of(:FeatureEnvy)
     end
     it 'should not report single use' do
-      expect('def no_envy(arga) arga.barg(@item) end').not_to reek
+      expect('def no_envy(arga) arga.barg(@item) end').not_to reek_of(:FeatureEnvy)
     end
     it 'should not report return value' do
-      expect('def no_envy(arga) arga.barg(@item); arga end').not_to reek
+      expect('def no_envy(arga) arga.barg(@item); arga end').not_to reek_of(:FeatureEnvy)
     end
     it 'should ignore global variables' do
-      expect('def no_envy() $s2.to_a; $s2[@item] end').not_to reek
+      expect('def no_envy() $s2.to_a; $s2[@item] end').not_to reek_of(:FeatureEnvy)
     end
     it 'should not report class methods' do
-      expect('def simple() self.class.new.flatten_merge(self) end').not_to reek
+      expect('def simple() self.class.new.flatten_merge(self) end').
+        not_to reek_of(:FeatureEnvy)
     end
     it 'should not report single use of an ivar' do
-      expect('def no_envy() @item.to_a end').not_to reek
+      expect('def no_envy() @item.to_a end').not_to reek_of(:FeatureEnvy)
     end
     it 'should not report returning an ivar' do
-      expect('def no_envy() @item.to_a; @item end').not_to reek
+      expect('def no_envy() @item.to_a; @item end').not_to reek_of(:FeatureEnvy)
     end
     it 'should not report ivar usage in a parameter' do
-      expect('def no_envy() @item.price + tax(@item) - savings(@item) end').not_to reek
+      expect('def no_envy() @item.price + tax(@item) - savings(@item) end').
+        not_to reek_of(:FeatureEnvy)
     end
     it 'should not report single use of an lvar' do
-      expect('def no_envy() lv = @item; lv.to_a end').not_to reek
+      expect('def no_envy() lv = @item; lv.to_a end').not_to reek_of(:FeatureEnvy)
     end
     it 'should not report returning an lvar' do
-      expect('def no_envy() lv = @item; lv.to_a; lv end').not_to reek
+      expect('def no_envy() lv = @item; lv.to_a; lv end').not_to reek_of(:FeatureEnvy)
     end
     it 'ignores lvar usage in a parameter' do
-      expect('def no_envy() lv = @item; lv.price + tax(lv) - savings(lv); end').not_to reek
+      expect('def no_envy() lv = @item; lv.price + tax(lv) - savings(lv); end').
+        not_to reek_of(:FeatureEnvy)
     end
     it 'ignores multiple ivars' do
       src = <<EOS
@@ -52,7 +55,7 @@ describe FeatureEnvy do
     @nother.d
   end
 EOS
-      expect(src).not_to reek
+      expect(src).not_to reek_of(:FeatureEnvy)
       #
       # def other.func(me)
       #   a
@@ -120,6 +123,36 @@ EOS
     expect('def func() other.a; other.b; nother.c end').not_to reek_of(:FeatureEnvy)
   end
 
+  it 'counts =~ as a call' do
+    src = <<-EOS
+    def foo arg
+      arg =~ /bar/
+    end
+    EOS
+    expect(src).to reek_of :FeatureEnvy
+  end
+
+  it 'counts += as a call' do
+    src = <<-EOS
+    def foo arg
+      arg += 1
+    end
+    EOS
+    expect(src).to reek_of :FeatureEnvy
+  end
+
+  it 'counts ivar assignment as call to self' do
+    src = <<-EOS
+    def foo
+      bar = baz(1, 2)
+
+      @quuz = bar.qux
+      @zyxy = bar.foobar
+    end
+    EOS
+    expect(src).not_to reek_of :FeatureEnvy
+  end
+
   it 'counts self references correctly' do
     src = <<EOS
 def adopt(other)
@@ -130,7 +163,7 @@ def adopt(other)
   self
 end
 EOS
-    expect(src).not_to reek
+    expect(src).not_to reek_of(:FeatureEnvy)
   end
 end
 
@@ -147,7 +180,7 @@ def report
   @report
 end
 EOS
-    expect(ruby).not_to reek
+    expect(ruby).not_to reek_of(:FeatureEnvy)
   end
 
   it 'interprets << correctly' do
@@ -161,7 +194,7 @@ def report_on(report)
 end
 EOS
 
-    expect(ruby).not_to reek
+    expect(ruby).not_to reek_of(:FeatureEnvy)
   end
 end
 
@@ -186,7 +219,7 @@ end
 EOS
       source = src.to_reek_source
       sniffer = Sniffer.new(source)
-      @mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
+      @mctx = CodeParser.new(sniffer).process_def(source.syntax_tree)
       @smells = @detector.examine_context(@mctx)
     end
     it 'reports only that smell' do

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -22,13 +22,14 @@ describe IrresponsibleModule do
   end
 
   it 'does not report a class having a comment' do
-    src = <<EOS
-# test class
-class Responsible; end
-EOS
+    src = <<-EOS
+      # test class
+      class Responsible; end
+    EOS
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     expect(@detector.examine_context(ctx)).to be_empty
   end
+
   it 'reports a class without a comment' do
     src = "class #{@bad_module_name}; end"
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
@@ -39,21 +40,28 @@ EOS
     expect(smells[0].lines).to eq([1])
     expect(smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]).to eq(@bad_module_name)
   end
+
   it 'reports a class with an empty comment' do
-    src = <<EOS
-#
-#
-#
-class #{@bad_module_name}; end
-EOS
-    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(IrresponsibleModule::SMELL_CLASS)
-    expect(smells[0].subclass).to eq(IrresponsibleModule::SMELL_SUBCLASS)
-    expect(smells[0].lines).to eq([4])
-    expect(smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]).to eq(@bad_module_name)
+    src = <<-EOS
+      #
+      #
+      #
+      class #{@bad_module_name}; end
+    EOS
+    expect(src).to smell_of IrresponsibleModule
   end
+
+  it 'reports a class with a preceding comment with intermittent material' do
+    src = <<-EOS
+      # This is a valid comment
+
+      require 'foo'
+
+      class Bar; end
+    EOS
+    expect(src).to reek_of(:IrresponsibleModule)
+  end
+
   it 'reports a fq module name correctly' do
     src = 'class Foo::Bar; end'
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)

data/spec/reek/smells/module_initialize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'reek/smells/module_initialize'
+require 'reek/smells/smell_detector_shared'
+
+include Reek::Smells
+
+describe ModuleInitialize do
+  context 'module' do
+    context 'with method named initialize' do
+      it 'smells' do
+        src = <<-EOF
+          module A
+            def initialize; end
+          end
+        EOF
+        expect(src).to smell_of(ModuleInitialize)
+      end
+    end
+  end
+end

data/spec/reek/smells/prima_donna_method_spec.rb

@@ -23,8 +23,8 @@ describe PrimaDonnaMethod do
       smells = detector.examine_context(ctx)
       warning = smells[0]
 
-      expect(warning.smell['class']).to eq('PrimaDonnaMethod')
-      expect(warning.smell['subclass']).to eq('PrimaDonnaMethod')
+      expect(warning.smell_class).to eq('PrimaDonnaMethod')
+      expect(warning.subclass).to eq('PrimaDonnaMethod')
       expect(warning.lines).to eq([1])
     end
   end

data/spec/reek/smells/repeated_conditional_spec.rb

@@ -63,11 +63,17 @@ EOS
       @ctx = CodeContext.new(nil, ast)
       @conds = @detector.conditional_counts(@ctx)
     end
+
     it 'finds both conditionals' do
       expect(@conds.length).to eq(2)
     end
+
+    it 'returns the condition expr' do
+      expect(@conds.keys[1]).to eq(@cond_expr)
+    end
+
     it 'knows there are three copies' do
-      expect(@conds[@cond_expr].length).to eq(3)
+      expect(@conds.values[1].length).to eq(3)
     end
 
     context 'looking at the YAML' do
@@ -86,7 +92,7 @@ EOS
         expect(@yaml).to match(/subclass:\s*RepeatedConditional/)
       end
       it 'reports the expression' do
-        expect(@yaml).to match(/expression:\s*"?\(#{@cond}\)"?/)
+        expect(@yaml).to match(/expression:\s*(! )?['"]?#{@cond}["']?/)
       end
       it 'reports the number of occurrences' do
         expect(@yaml).to match(/occurrences:\s*3/)
@@ -125,8 +131,8 @@ EOS
     it 'returns the condition expr' do
       expect(@conds.keys[0]).to eq(@cond_expr)
     end
-    it 'knows there are three copies' do
-      expect(@conds[@cond_expr].length).to eq(2)
+    it 'knows there are two copies' do
+      expect(@conds.values[0].length).to eq(2)
     end
   end
 

data/spec/reek/smells/too_many_instance_variables_spec.rb

@@ -17,40 +17,66 @@ describe TooManyInstanceVariables do
 
   context 'counting instance variables' do
     it 'should not report 9 ivars' do
-      expect('# clean class for testing purposes
-class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=4; end;end').not_to reek
+      src = <<-EOS
+        class Empty
+          def ivars
+            @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=4
+          end
+        end
+      EOS
+      expect(src).not_to reek_of(:TooManyInstanceVariables)
     end
 
     it 'counts each ivar only once' do
-      expect('# clean class for testing purposes
-class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=4;@aa=3; end;end').not_to reek
+      src = <<-EOS
+        class Empty
+          def ivars
+            @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=4
+            @aa=3
+          end
+        end
+      EOS
+      expect(src).not_to reek_of(:TooManyInstanceVariables)
     end
 
     it 'should report 10 ivars' do
-      expect('# smelly class for testing purposes
-class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=@aj=4; end;end').to reek_only_of(:TooManyInstanceVariables)
+      src = <<-EOS
+        class Empty
+          def ivars
+            @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=@aj=4
+          end
+        end
+      EOS
+      expect(src).to reek_of(:TooManyInstanceVariables)
     end
 
     it 'should not report 10 ivars in 2 extensions' do
-      src = <<EOS
-# clean class for testing purposes
-class Full;def ivars_a() @aa=@ab=@ac=@ad=@ae; end;end
-# clean class for testing purposes
-class Full;def ivars_b() @af=@ag=@ah=@ai=@aj; end;end
-EOS
-      expect(src).not_to reek
+      src = <<-EOS
+        class Full
+          def ivars_a
+            @aa=@ab=@ac=@ad=@ae
+          end
+        end
+
+        class Full
+          def ivars_b
+            @af=@ag=@ah=@ai=@aj
+          end
+        end
+      EOS
+      expect(src).not_to reek_of(:TooManyInstanceVariables)
     end
   end
 
   it 'reports correctly when the class has 10 instance variables' do
-    src = <<EOS
-# smelly class for testing purposes
-class Empty
-  def ivars
-    @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=@aj=4
-  end
-end
-EOS
+    src = <<-EOS
+      # Comment
+      class Empty
+        def ivars
+          @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=@aj=4
+        end
+      end
+    EOS
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
     expect(@warning.source).to eq(@source_name)

data/spec/reek/smells/too_many_statements_spec.rb

@@ -10,7 +10,7 @@ include Reek::Smells
 def process_method(src)
   source = src.to_reek_source
   sniffer = Core::Sniffer.new(source)
-  Core::CodeParser.new(sniffer).process_defn(source.syntax_tree)
+  Core::CodeParser.new(sniffer).process_def(source.syntax_tree)
 end
 
 def process_singleton_method(src)
@@ -148,6 +148,11 @@ describe TooManyStatements, 'does not count control statements' do
     expect(method.num_statements).to eq(0)
   end
 
+  it 'counts extra statements in an if condition' do
+    method = process_method('def one() if begin val = callee(); val < 4 end; end; end')
+    expect(method.num_statements).to eq(1)
+  end
+
   it 'counts 1 statement in a while loop' do
     method = process_method('def one() while val < 4; callee(); end; end')
     expect(method.num_statements).to eq(1)
@@ -158,6 +163,11 @@ describe TooManyStatements, 'does not count control statements' do
     expect(method.num_statements).to eq(3)
   end
 
+  it 'counts extra statements in a while condition' do
+    method = process_method('def one() while begin val = callee(); val < 4 end; end; end')
+    expect(method.num_statements).to eq(1)
+  end
+
   it 'counts 1 statement in a until loop' do
     method = process_method('def one() until val < 4; callee(); end; end')
     expect(method.num_statements).to eq(1)

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -18,7 +18,7 @@ describe UncommunicativeVariableName do
   context 'field name' do
     it 'does not report use of one-letter fieldname' do
       src = 'class Thing; def simple(fred) @x end end'
-      expect(src).not_to smell_of(UncommunicativeVariableName)
+      expect(src).not_to reek_of(:UncommunicativeVariableName)
     end
     it 'reports one-letter fieldname in assignment' do
       src = 'class Thing; def simple(fred) @x = fred end end'

data/spec/reek/smells/utility_function_spec.rb

@@ -29,23 +29,22 @@ describe UtilityFunction do
       expect(@detector.examine_context(ctx)).to be_empty
     end
     it 'does not report literal' do
-      expect('def simple() 3; end').not_to reek
+      expect('def simple() 3; end').not_to reek_of(:UtilityFunction)
     end
     it 'does not report instance variable reference' do
-      expect('def simple() @yellow end').not_to reek
+      expect('def simple() @yellow end').not_to reek_of(:UtilityFunction)
     end
     it 'does not report vcall' do
-      expect('def simple() y end').not_to reek
+      expect('def simple() y end').not_to reek_of(:UtilityFunction)
     end
     it 'does not report references to self' do
-      expect('def into; self; end').not_to reek
+      expect('def into; self; end').not_to reek_of(:UtilityFunction)
     end
     it 'recognises an ivar reference within a block' do
-      expect('def clean(text) text.each { @fred = 3} end').not_to reek
+      expect('def clean(text) text.each { @fred = 3} end').not_to reek_of(:UtilityFunction)
     end
     it 'copes with nil superclass' do
-      expect('# clean class for testing purposes
-class Object; def is_maybe?() false end end').not_to reek
+      expect('class Object; def is_maybe?() false end end').not_to reek_of(:UtilityFunction)
     end
   end
 
@@ -54,7 +53,7 @@ class Object; def is_maybe?() false end end').not_to reek
       expect('def simple(arga) arga.to_s end').not_to reek_of(:UtilityFunction, /simple/)
     end
     it 'does not report a call to a constant' do
-      expect('def simple(arga) FIELDS[arga] end').not_to reek
+      expect('def simple(arga) FIELDS[arga] end').not_to reek_of(:UtilityFunction)
     end
   end
 
@@ -66,36 +65,38 @@ class Object; def is_maybe?() false end end').not_to reek
       expect('def simple(arga=local) arga.to_s end').not_to reek_of(:UtilityFunction)
     end
     it 'should count usages of self'do
-      expect('def <=>(other) Options[:sort_order].compare(self, other) end').not_to reek
+      expect('def <=>(other) Options[:sort_order].compare(self, other) end').
+        not_to reek_of(:UtilityFunction)
     end
     it 'should count self reference within a dstr' do
-      expect('def as(alias_name); "#{self} as #{alias_name}".to_sym; end').not_to reek
+      expect('def as(alias_name); "#{self} as #{alias_name}".to_sym; end').
+        not_to reek_of(:UtilityFunction)
     end
     it 'should count calls to self within a dstr' do
-      expect('def to_sql; "\'#{self.gsub(/\'/, "\'\'")}\'"; end').not_to reek
+      expect('def to_sql; "\'#{self.gsub(/\'/, "\'\'")}\'"; end').
+        not_to reek_of(:UtilityFunction)
     end
     it 'should report message chain' do
       expect('def simple(arga) arga.b.c end').to reek_of(:UtilityFunction, /simple/)
     end
 
     it 'does not report a method that calls super' do
-      expect('def child(arg) super; arg.to_s; end').not_to reek
+      expect('def child(arg) super; arg.to_s; end').not_to reek_of(:UtilityFunction)
     end
 
     it 'should recognise a deep call' do
-      src = <<EOS
-# clean class for testing purposes
-  class Red
-    def deep(text)
-      text.each { |mod| atts = shelve(mod) }
-    end
+      src = <<-EOS
+        class Red
+          def deep(text)
+            text.each { |mod| atts = shelve(mod) }
+          end
 
-    def shelve(val)
-      @shelf << val
-    end
-  end
-EOS
-      expect(src).not_to reek
+          def shelve(val)
+            @shelf << val
+          end
+        end
+      EOS
+      expect(src).not_to reek_of(:UtilityFunction)
     end
   end
 
@@ -108,7 +109,7 @@ end
 EOS
       source = src.to_reek_source
       sniffer = Sniffer.new(source)
-      mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
+      mctx = CodeParser.new(sniffer).process_def(source.syntax_tree)
       @warning = @detector.examine_context(mctx)[0]   # SMELL: too cumbersome!
     end