reek 1.3.8 → 1.4.0

data/spec/reek/smells/behaves_like_variable_detector.rb

@@ -2,7 +2,7 @@ shared_examples_for 'a variable detector' do
   context 'with no variables' do
     it "doesn't record a smell" do
       @detector.examine_context(@ctx)
-      @detector.smells_found.length.should == 0
+      expect(@detector.smells_found.length).to eq(0)
     end
   end
 
@@ -14,10 +14,10 @@ shared_examples_for 'a variable detector' do
     end
 
     it 'records only one smell' do
-      @detector.smells_found.length.should == 1
+      expect(@detector.smells_found.length).to eq(1)
     end
     it 'mentions the variable name in the report' do
-      @detector.should have_smell([/something/])
+      expect(@detector).to have_smell([/something/])
     end
   end
 
@@ -29,11 +29,11 @@ shared_examples_for 'a variable detector' do
     end
 
     it 'records both smells' do
-      @detector.num_smells.should == 2
+      expect(@detector.num_smells).to eq(2)
     end
     it 'mentions both variable names in the report' do
-      @detector.should have_smell([/something/])
-      @detector.should have_smell([/something_else/])
+      expect(@detector).to have_smell([/something/])
+      expect(@detector).to have_smell([/something_else/])
     end
   end
 end

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -9,34 +9,34 @@ describe BooleanParameter do
     context 'in a method' do
       it 'reports a parameter defaulted to true' do
         src = 'def cc(arga = true) end'
-        src.should smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
+        expect(src).to smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
       end
       it 'reports a parameter defaulted to false' do
         src = 'def cc(arga = false) end'
-        src.should smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
+        expect(src).to smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
       end
       it 'reports two parameters defaulted to booleans' do
         src = 'def cc(nowt, arga = true, argb = false, &blk) end'
-        src.should smell_of(BooleanParameter,
-          {BooleanParameter::PARAMETER_KEY => 'arga'},
-          {BooleanParameter::PARAMETER_KEY => 'argb'})
+        expect(src).to smell_of(BooleanParameter,
+                                { BooleanParameter::PARAMETER_KEY => 'arga' },
+                                BooleanParameter::PARAMETER_KEY => 'argb')
       end
     end
 
     context 'in a singleton method' do
       it 'reports a parameter defaulted to true' do
         src = 'def self.cc(arga = true) end'
-        src.should smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
+        expect(src).to smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
       end
       it 'reports a parameter defaulted to false' do
         src = 'def fred.cc(arga = false) end'
-        src.should smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
+        expect(src).to smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
       end
       it 'reports two parameters defaulted to booleans' do
         src = 'def Module.cc(nowt, arga = true, argb = false, &blk) end'
-        src.should smell_of(BooleanParameter,
-          {BooleanParameter::PARAMETER_KEY => 'arga'},
-          {BooleanParameter::PARAMETER_KEY => 'argb'})
+        expect(src).to smell_of(BooleanParameter,
+                                { BooleanParameter::PARAMETER_KEY => 'arga' },
+                                BooleanParameter::PARAMETER_KEY => 'argb')
       end
     end
   end
@@ -54,13 +54,13 @@ describe BooleanParameter do
       ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
       @detector.examine(ctx)
       smells = @detector.smells_found.to_a
-      smells.length.should == 1
-      smells[0].smell_class.should == BooleanParameter::SMELL_CLASS
-      smells[0].smell[BooleanParameter::PARAMETER_KEY].should == 'arga'
-      smells[0].source.should == @source_name
-      smells[0].smell_class.should == BooleanParameter::SMELL_CLASS
-      smells[0].subclass.should == BooleanParameter::SMELL_SUBCLASS
-      smells[0].lines.should == [1]
+      expect(smells.length).to eq(1)
+      expect(smells[0].smell_class).to eq(BooleanParameter::SMELL_CLASS)
+      expect(smells[0].smell[BooleanParameter::PARAMETER_KEY]).to eq('arga')
+      expect(smells[0].source).to eq(@source_name)
+      expect(smells[0].smell_class).to eq(BooleanParameter::SMELL_CLASS)
+      expect(smells[0].subclass).to eq(BooleanParameter::SMELL_SUBCLASS)
+      expect(smells[0].lines).to eq([1])
     end
   end
 end

data/spec/reek/smells/class_variable_spec.rb

@@ -18,11 +18,11 @@ describe ClassVariable do
   context 'with no class variables' do
     it 'records nothing in the class' do
       exp = ast(:class, :Fred)
-      @detector.examine_context(CodeContext.new(nil, exp)).should be_empty
+      expect(@detector.examine_context(CodeContext.new(nil, exp))).to be_empty
     end
     it 'records nothing in the module' do
       exp = ast(:module, :Fred)
-      @detector.examine_context(CodeContext.new(nil, exp)).should be_empty
+      expect(@detector.examine_context(CodeContext.new(nil, exp))).to be_empty
     end
   end
 
@@ -33,10 +33,10 @@ describe ClassVariable do
         @smells = @detector.examine_context(CodeContext.new(nil, ast))
       end
       it 'records only that class variable' do
-        @smells.length.should == 1
+        expect(@smells.length).to eq(1)
       end
       it 'records the variable name' do
-        @smells[0].smell[ClassVariable::VARIABLE_KEY].should == @class_variable
+        expect(@smells[0].smell[ClassVariable::VARIABLE_KEY]).to eq(@class_variable)
       end
     end
 
@@ -91,10 +91,10 @@ end
 EOS
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
-    @warning.source.should == @source_name
-    @warning.smell_class.should == ClassVariable::SMELL_CLASS
-    @warning.subclass.should == ClassVariable::SMELL_SUBCLASS
-    @warning.smell[ClassVariable::VARIABLE_KEY].should == @class_variable
-    @warning.lines.should == [2]
+    expect(@warning.source).to eq(@source_name)
+    expect(@warning.smell_class).to eq(ClassVariable::SMELL_CLASS)
+    expect(@warning.subclass).to eq(ClassVariable::SMELL_SUBCLASS)
+    expect(@warning.smell[ClassVariable::VARIABLE_KEY]).to eq(@class_variable)
+    expect(@warning.lines).to eq([2])
   end
 end

data/spec/reek/smells/control_parameter_spec.rb

@@ -12,233 +12,257 @@ describe ControlParameter do
 
   it_should_behave_like 'SmellDetector'
 
-  it 'should not report a ternary check on an ivar' do
-    src = 'def simple(arga) @ivar ? arga : 3 end'
-    src.should_not smell_of(ControlParameter)
-  end
-
-  it 'should not report a ternary check on a lvar' do
-    src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
-    src.should_not smell_of(ControlParameter)
-  end
 
-  it 'should not report when parameter is unused' do
-    src = 'def simple(arg) test = 1 end'
-    src.should_not smell_of(ControlParameter)
-  end
+  context 'parameter not used to determine code path' do
+    it 'does not report a ternary check on an ivar' do
+      src = 'def simple(arga) @ivar ? arga : 3 end'
+      expect(src).not_to smell_of(ControlParameter)
+    end
 
-  it 'should not report when parameter is used inside conditional' do
-    src = 'def simple(arg) if true then puts arg end end'
-    src.should_not smell_of(ControlParameter)
-  end
+    it 'does not report a ternary check on a lvar' do
+      src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
+      expect(src).not_to smell_of(ControlParameter)
+    end
 
-  it 'should not report when used in first conditional but not second' do
-    src = <<EOS
-def things(arg)
-  if arg
-    puts arg
-  end
-  if arg
-    puts 'a'
-  end
-end
-EOS
-    src.should_not smell_of(ControlParameter)
-  end
+    it 'does not report when parameter is unused' do
+      src = 'def simple(arg) test = 1 end'
+      expect(src).not_to smell_of(ControlParameter)
+    end
 
-  it 'should not report when used in second conditional but not first' do
-    src = <<EOS
-def things(arg)
-  if arg
-    puts 'a'
-  end
-  if arg
-    puts arg
-  end
-end
-EOS
-    src.should_not smell_of(ControlParameter)
+    it 'does not report when parameter is used inside conditional' do
+      src = 'def simple(arg) if true then puts arg end end'
+      expect(src).not_to smell_of(ControlParameter)
+    end
   end
 
-  it 'should not report on complex non smelly method' do
-    src = <<EOS
-  def self.guess(arg)
-    case arg
-    when ""
-      t = self
-    when "a"
-      t = Switch::OptionalArgument
-    when "b"
-      t = Switch::PlacedArgument
-    else
-      t = Switch::RequiredArgument
-    end
-    self >= t or incompatible_argument_styles(arg, t)
-    t
-  end
-EOS
-    src.should_not smell_of(ControlParameter)
-  end
 
   context 'parameter only used to determine code path' do
-    it 'should report a ternary check on a parameter' do
+    it 'reports a ternary check on a parameter' do
       src = 'def simple(arga) arga ? @ivar : 3 end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arga')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arga')
     end
 
-    it 'should spot a couple inside a block' do
+    it 'reports a couple inside a block' do
       src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on an if statement modifier' do
+    it 'reports on an if statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') if arg end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on an unless statement modifier' do
+    it 'reports on an unless statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') unless arg end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on if control expression' do
+    it 'reports on if control expression' do
       src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => \'A\') end end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on if control expression with &&' do
+    it 'reports on if control expression with &&' do
       src = 'def simple(arg) if arg && true then puts "arg" end end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on if control expression with preceding &&' do
+    it 'reports on if control expression with preceding &&' do
       src = 'def simple(arg) if true && arg then puts "arg" end end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on if control expression with two && conditions' do
+    it 'reports on if control expression with two && conditions' do
       src = 'def simple(a) ag = {}; if a && true && true then puts "2" end end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'a')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'a')
     end
 
-    it 'should report on if control expression with ||' do
+    it 'reports on if control expression with ||' do
       src = 'def simple(arg) args = {}; if arg || true then puts "arg" end end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on if control expression with or' do
+    it 'reports on if control expression with or' do
       src = 'def simple(arg) args = {}; if arg or true then puts "arg" end end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on && notation' do
+    it 'reports on if control expression with if' do
+      src = 'def simple(arg) args = {}; if (arg if true) then puts "arg" end end'
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'reports on && notation' do
       src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => \'A\') end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on || notation' do
+    it 'reports on || notation' do
       src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => \'A\') end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on case statement' do
+    it 'reports on case statement' do
       src = 'def simple(arg) case arg when nil; nil when false; nil else nil end end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report when the argument is a hash on which we access a key' do
-      src = 'def simple(arg) if arg[\'a\'] then puts \'a\' else puts \'b\' end end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    it 'reports on nested if statements that are both control parameters' do
+      src = <<-EOS
+        def nested(arg)
+          if arg
+            puts 'a'
+            puts 'b' if arg
+          end
+        end
+      EOS
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on nested if statements that are both control parameters' do
-      src = <<EOS
-def nested(arg)
-  if arg
-    puts 'a'
-    puts 'b' if arg
-  end
-end
-EOS
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    it 'reports on nested if statements where the inner if is a control parameter' do
+      src = <<-EOS
+        def nested(arg)
+          if true
+            puts 'a'
+            puts 'b' if arg
+          end
+        end
+      EOS
+      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
     end
 
-    it 'should report on nested if statements where the inner if is a control parameter' do
-      src = <<EOS
-def nested(arg)
-  if true
-    puts 'a'
-    puts 'b' if arg
-  end
-end
-EOS
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    it 'reports on explicit comparison in the condition' do
+      src = 'def simple(arg) if arg == :foo then :foo else :bar end end'
+      expect(src).to smell_of(ControlParameter)
+    end
+
+    it 'reports on explicit negative comparison in the condition' do
+      src = 'def simple(arg) if arg != :foo then :bar else :foo end end'
+      expect(src).to smell_of(ControlParameter)
     end
   end
 
   context 'parameter used besides determining code path' do
-    it 'should not report on if conditional expression' do
+    it 'does not report on if conditional expression' do
       src = 'def simple(arg) if arg then use(arg) else use(@other) end end'
-      src.should_not smell_of(ControlParameter)
+      expect(src).not_to smell_of(ControlParameter)
     end
 
-    it 'should not report on an if statement modifier' do
+    it 'does not report on an if statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) if arg end'
-      src.should_not smell_of(ControlParameter)
+      expect(src).not_to smell_of(ControlParameter)
     end
 
-    it 'should not report on an unless statement modifier' do
+    it 'does not report on an unless statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) unless arg end'
-      src.should_not smell_of(ControlParameter)
+      expect(src).not_to smell_of(ControlParameter)
     end
 
-    it 'should not report on if control expression' do
+    it 'does not report on if control expression' do
       src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => arg) end end'
-      src.should_not smell_of(ControlParameter)
+      expect(src).not_to smell_of(ControlParameter)
     end
 
-    it 'should not report on if control expression with &&' do
+    it 'does not report on if control expression with &&' do
       src = 'def simple(arg) if arg && true then puts arg end end'
-      src.should_not smell_of(ControlParameter)
+      expect(src).not_to smell_of(ControlParameter)
     end
 
-    it 'should not report on && notation' do
+    it 'does not report on && notation' do
       src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => arg) end'
-      src.should_not smell_of(ControlParameter)
+      expect(src).not_to smell_of(ControlParameter)
     end
 
-    it 'should not report on || notation' do
+    it 'does not report on || notation' do
       src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => arg) end'
-      src.should_not smell_of(ControlParameter)
+      expect(src).not_to smell_of(ControlParameter)
     end
 
-    it 'should not report when parameter is used outside conditional' do
+    it 'does not report when parameter is used outside conditional' do
       src = 'def simple(arg) puts arg; if arg then @a = 1 end end'
-      src.should_not smell_of(ControlParameter)
+      expect(src).not_to smell_of(ControlParameter)
+    end
+
+    it 'does not report when parameter is used as a method call argument in a condition' do
+      src = 'def simple(arg) if foo(arg) then @a = 1 end end'
+      expect(src).not_to smell_of(ControlParameter)
+    end
+
+    it 'does not report when parameter is used as a method call receiver in a condition' do
+      src = 'def simple(arg) if arg.foo? then @a = 1 end end'
+      expect(src).not_to smell_of(ControlParameter)
+    end
+
+    it 'does not report when the argument is a hash on which we access a key' do
+      src = 'def simple(arg) if arg[\'a\'] then puts \'a\' else puts \'b\' end end'
+      expect(src).not_to smell_of ControlParameter
+    end
+
+    it 'does not report when used in first conditional but not second' do
+      src = <<-EOS
+        def things(arg)
+          if arg
+            puts arg
+          end
+          if arg
+            puts 'a'
+          end
+        end
+      EOS
+      expect(src).not_to smell_of(ControlParameter)
+    end
+
+    it 'does not report when used in second conditional but not first' do
+      src = <<-EOS
+        def things(arg)
+          if arg
+            puts 'a'
+          end
+          if arg
+            puts arg
+          end
+        end
+      EOS
+      expect(src).not_to smell_of(ControlParameter)
+    end
+
+    it 'does not report when used in body of control flow operator' do
+      src = <<-EOS
+        def foo(arg)
+          case arg
+          when :bar
+            puts 'a'
+          else
+            puts 'b'
+          end
+          qux or quuz(arg)
+        end
+      EOS
+      expect(src).not_to smell_of(ControlParameter)
     end
   end
 
   context 'when a smell is reported' do
     before :each do
-      src = <<EOS
-def things(arg)
-  @text.map do |blk|
-    arg ? blk : "blk"
-  end
-  puts "hello" if arg
-end
-EOS
+      src = <<-EOS
+        def things(arg)
+          @text.map do |blk|
+            arg ? blk : "blk"
+          end
+          puts "hello" if arg
+        end
+      EOS
       ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine(ctx)
-      smells.length.should == 1
+      expect(smells.length).to eq(1)
       @warning = smells[0]
     end
 
     it_should_behave_like 'common fields set correctly'
 
     it 'has the correct fields' do
-      @warning.smell[ControlParameter::PARAMETER_KEY].should == 'arg'
-      @warning.lines.should == [3, 5]
+      expect(@warning.smell[ControlParameter::PARAMETER_KEY]).to eq('arg')
+      expect(@warning.lines).to eq([3, 5])
     end
   end
 end