reek 4.4.0 → 4.4.1

data/spec/reek/smells/class_variable_spec.rb

@@ -1,98 +1,111 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/class_variable'
-require_lib 'reek/context/module_context'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::ClassVariable do
-  let(:class_variable) { '@@things' }
-  let(:detector) { build(:smell_detector, smell_type: :ClassVariable) }
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        @@bravo = 5
+      end
+    EOS
 
-  it_should_behave_like 'SmellDetector'
+    expect(src).to reek_of(:ClassVariable,
+                           lines:   [2],
+                           context: 'Alfa',
+                           message: "declares the class variable '@@bravo'",
+                           source:  'string',
+                           name:    '@@bravo')
+  end
 
-  context 'with no class variables' do
-    it 'records nothing in the class' do
-      exp = sexp(:class, :Fred)
-      expect(detector.sniff(Reek::Context::CodeContext.new(nil, exp))).to be_empty
-    end
+  it 'does count all class variables' do
+    src = <<-EOS
+      class Alfa
+        @@bravo = 42
+        @@charlie = 99
+      end
+    EOS
 
-    it 'records nothing in the module' do
-      exp = sexp(:module, :Fred)
-      expect(detector.sniff(Reek::Context::CodeContext.new(nil, exp))).to be_empty
-    end
+    expect(src).to reek_of(:ClassVariable, name: '@@bravo')
+    expect(src).to reek_of(:ClassVariable, name: '@@charlie')
   end
 
-  context 'with one class variable' do
-    shared_examples_for 'one variable found' do
-      let(:ast) { Reek::Source::SourceCode.from(src).syntax_tree }
-      let(:smells) { detector.sniff(Reek::Context::CodeContext.new(nil, ast)) }
-
-      it 'records only that class variable' do
-        expect(smells.length).to eq(1)
+  it 'does not report class instance variables' do
+    src = <<-EOS
+      class Alfa
+        @bravo = 42
       end
+    EOS
 
-      it 'records the variable name' do
-        expect(smells[0].parameters[:name]).to eq(class_variable)
-      end
-    end
+    expect(src).to_not reek_of(:ClassVariable)
+  end
 
-    ['class', 'module'].each do |scope|
-      context "declared in a #{scope}" do
-        let(:src) { "#{scope} Fred; #{class_variable} = {}; end" }
-        it_should_behave_like 'one variable found'
-      end
+  context 'with no class variables' do
+    it 'records nothing in the class' do
+      src = <<-EOS
+        class Alfa
+          def bravo; end
+        end
+      EOS
 
-      context "used in a #{scope}" do
-        let(:src) { "#{scope} Fred; def jim() #{class_variable} = {}; end; end" }
-        it_should_behave_like 'one variable found'
-      end
+      expect(src).to_not reek_of(:ClassVariable)
+    end
 
-      context "indexed in a #{scope}" do
-        let(:src) { "#{scope} Fred; def jim() #{class_variable}[mash] = {}; end; end" }
-        it_should_behave_like 'one variable found'
-      end
+    it 'records nothing in the module' do
+      src = <<-EOS
+        module Alfa
+          def bravo; end
+        end
+      EOS
 
-      context "declared and used in a #{scope}" do
-        let(:src) do
-          <<-EOS
-            #{scope} Fred
-              #{class_variable} = {}
-              def jim() #{class_variable} = {}; end
+      expect(src).to_not reek_of(:ClassVariable)
+    end
+  end
+
+  ['class', 'module'].each do |scope|
+    context "Scoped to #{scope}" do
+      context 'set in a method' do
+        it 'reports correctly' do
+          src = <<-EOS
+            #{scope} Alfa
+              def bravo
+                @@charlie = {}
+              end
             end
           EOS
+
+          expect(src).to reek_of(:ClassVariable)
         end
-        it_should_behave_like 'one variable found'
       end
 
-      context "used twice in a #{scope}" do
-        let(:src) do
-          <<-EOS
-            #{scope} Fred
-              def jeff() #{class_variable} = {}; end
-              def jim()  #{class_variable} = {}; end
+      context 'used in a method' do
+        it 'reports correctly' do
+          src = <<-EOS
+            #{scope} Alfa
+              def bravo
+                puts @@charlie
+              end
             end
           EOS
+
+          expect(src).to reek_of(:ClassVariable)
         end
-        it_should_behave_like 'one variable found'
       end
-    end
-  end
 
-  context 'when a smell is reported' do
-    let(:warning) do
-      src = <<-EOS
-        module Fred
-          #{class_variable} = {}
-        end
-      EOS
-      ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector.sniff(ctx).first
-    end
+      context "set in #{scope} and used in a method" do
+        it 'reports correctly' do
+          src = <<-EOS
+            #{scope} Alfa
+              @@bravo = 42
 
-    it_should_behave_like 'common fields set correctly'
+              def charlie
+                puts @@bravo
+              end
+            end
+          EOS
 
-    it 'reports the correct values' do
-      expect(warning.parameters[:name]).to eq(class_variable)
-      expect(warning.lines).to eq([2])
+          expect(src).to reek_of(:ClassVariable)
+        end
+      end
     end
   end
 end

data/spec/reek/smells/control_parameter_spec.rb

@@ -1,292 +1,252 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/control_parameter'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::ControlParameter do
-  let(:detector) { build(:smell_detector, smell_type: :ControlParameter) }
+  it 'reports the right values' do
+    src = <<-EOS
+      def alfa(bravo)
+        bravo ? true : false
+      end
+    EOS
+
+    expect(src).to reek_of(:ControlParameter,
+                           lines:    [2],
+                           context:  'alfa',
+                           message:  "is controlled by argument 'bravo'",
+                           source:   'string',
+                           argument: 'bravo')
+  end
+
+  it 'does count all occurences' do
+    src = <<-EOS
+      def alfa(bravo, charlie)
+        bravo ? true : false
+        charlie ? true : false
+      end
+    EOS
 
-  it_should_behave_like 'SmellDetector'
+    expect(src).to reek_of(:ControlParameter, lines: [2], argument: 'bravo')
+    expect(src).to reek_of(:ControlParameter, lines: [3], argument: 'charlie')
+  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'
+      src = 'def alfa(bravo) @charlie ? bravo : false end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report a ternary check on a lvar' do
-      src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
+      src = 'def alfa(bravo) charlie = 27; charlie ? bravo : @delta end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when parameter is unused' do
-      src = 'def simple(arg) test = 1 end'
+      src = 'def alfa(bravo) charlie = 1 end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when parameter is used inside conditional' do
-      src = 'def simple(arg) if true then puts arg end end'
+      src = 'def alfa(bravo) if true then puts bravo end end'
       expect(src).not_to reek_of(:ControlParameter)
     end
   end
 
   context 'parameter only used to determine code path' do
     it 'reports a ternary check on a parameter' do
-      src = 'def simple(arga) arga ? @ivar : 3 end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arga')
+      src = 'def alfa(bravo); bravo ? true : false; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports a couple inside a block' do
-      src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); charlie.map { |delta| bravo ? delta : "#{delta}" }; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on an if statement modifier' do
-      src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') if arg end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); charlie if bravo; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on an unless statement modifier' do
-      src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') unless arg end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); charlie unless bravo; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on if control expression' do
-      src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => \'A\') end end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); if bravo then charlie end; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on if control expression with &&' do
-      src = 'def simple(arg) if arg && true then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); if bravo && true then charlie end; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
-    it 'reports on if control expression with preceding &&' do
-      src = 'def simple(arg) if true && arg then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+    it 'reports on if control expression with `and`' do
+      src = 'def alfa(bravo); if bravo and true then charlie end; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
-    it 'reports on if control expression with two && conditions' do
-      src = 'def simple(a) ag = {}; if a && true && true then puts "2" end end'
-      expect(src).to reek_of(:ControlParameter, argument: 'a')
+    it 'reports on if control expression with preceding &&' do
+      src = 'def alfa(bravo); if true && bravo then charlie end; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on if control expression with ||' do
-      src = 'def simple(arg) args = {}; if arg || true then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); if bravo || true then charlie end; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on if control expression with or' do
-      src = 'def simple(arg) args = {}; if arg or true then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); if bravo or true then charlie end; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     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 reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); if (bravo if true) then charlie end; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on && notation' do
-      src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => \'A\') end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); bravo && charlie; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on || notation' do
-      src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => \'A\') end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = 'def alfa(bravo); bravo || charlie; end'
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on case statement' do
-      src = 'def simple(arg) case arg when nil; nil when false; nil else nil end end'
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+      src = <<-EOS
+        def alfa(bravo)
+          case bravo
+          when nil then nil
+          else false
+          end
+        end
+      EOS
+
+      expect(src).to reek_of(:ControlParameter)
     end
 
-    it 'reports on nested if statements that are both control parameters' do
+    it 'reports on nested if statements that are both using control parameters' do
       src = <<-EOS
-        def nested(arg)
-          if arg
-            puts 'a'
-            puts 'b' if arg
+        def nested(bravo)
+          if bravo
+            charlie
+            charlie if bravo
           end
         end
       EOS
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on nested if statements where the inner if is a control parameter' do
       src = <<-EOS
-        def nested(arg)
+        def nested(bravo)
           if true
-            puts 'a'
-            puts 'b' if arg
+            charlie
+            charlie if bravo
           end
         end
       EOS
-      expect(src).to reek_of(:ControlParameter, argument: 'arg')
+
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on explicit comparison in the condition' do
-      src = 'def simple(arg) if arg == :foo then :foo else :bar end end'
+      src = 'def alfa(bravo); if bravo == charlie then charlie end; end'
       expect(src).to reek_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'
+      src = 'def alfa(bravo); if bravo != charlie then charlie end; end'
       expect(src).to reek_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'
+      src = 'def alfa(bravo); if bravo =~ charlie then charlie end; end'
       expect(src).to reek_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'
+      src = 'def alfa(bravo); if /charlie/ =~ bravo then charlie end; end'
       expect(src).to reek_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'
+      src = 'def alfa(bravo); if /charlie#{bravo}/ =~ delta then charlie end; end'
       expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports when the argument is a block parameter' do
-      src = <<-EOS
-        def foo &blk
-          bar(blk || proc {})
-        end
-      EOS
+      src = 'def bravo(&charlie); delta(charlie || proc {}); end'
       expect(src).to reek_of(:ControlParameter)
     end
   end
 
   context 'parameter used besides determining code path' 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 = 'def alfa(bravo); if bravo then charlie(bravo); end end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on an if statement modifier' do
-      src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) if arg end'
+      src = 'def alfa(bravo); charlie(bravo) if bravo; end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on an unless statement modifier' do
-      src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) unless arg end'
-      expect(src).not_to reek_of(:ControlParameter)
-    end
-
-    it 'does not report on if control expression' do
-      src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => arg) end end'
+      src = 'def alfa(bravo); charlie(bravo) unless bravo; end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on if control expression with &&' do
-      src = 'def simple(arg) if arg && true then puts arg end end'
+      src = 'def alfa(bravo) if bravo && true then puts bravo end end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on && notation' do
-      src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => arg) end'
+      src = 'def alfa(bravo); bravo && charlie(bravo); end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on || notation' do
-      src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => arg) end'
+      src = 'def alfa(bravo); bravo || charlie(bravo) end'
       expect(src).not_to reek_of(:ControlParameter)
     end
 
     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 = 'def alfa(bravo) puts bravo; if bravo then charlie end; end'
       expect(src).not_to reek_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'
+      src = 'def alfa(bravo); if charlie(bravo) then delta end; end'
       expect(src).not_to reek_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 reek_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 reek_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 reek_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
+      src = 'def alfa(bravo); if bravo.charlie? then delta end; end'
       expect(src).not_to reek_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'
+        def alfa(bravo)
+          case bravo
+          when :charlie
+            puts 'charlie'
           else
-            puts 'b'
-          end
-          qux or quuz(arg)
-        end
-      EOS
-      expect(src).not_to reek_of(:ControlParameter)
-    end
-  end
-
-  context 'when a smell is reported' do
-    let(:warning) do
-      src = <<-EOS
-        def things(arg)
-          @text.map do |blk|
-            arg ? blk : "blk"
+            puts 'delta'
           end
-          puts "hello" if arg
+          echo or foxtrot(bravo)
         end
       EOS
-      ctx = Reek::Context::MethodContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      smells = detector.run_for(ctx)
-      expect(smells.length).to eq(1)
-      smells.first
-    end
-
-    it_should_behave_like 'common fields set correctly'
-
-    it 'reports the argument' do
-      expect(warning.parameters[:argument]).to eq('arg')
-    end
-
-    it 'reports the lines' do
-      expect(warning.lines).to eq([3, 5])
-    end
 
-    it 'has the right message' do
-      expect(warning.message).to eq('is controlled by argument arg')
+      expect(src).not_to reek_of(:ControlParameter)
     end
   end
 end