reek 6.0.2 → 6.2.0

data/spec/reek/smell_detectors/boolean_parameter_spec.rb

@@ -1,93 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/boolean_parameter'
-
-RSpec.describe Reek::SmellDetectors::BooleanParameter do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa(bravo = true)
-      end
-    RUBY
-
-    expect(src).to reek_of(:BooleanParameter,
-                           lines: [1],
-                           context: 'alfa',
-                           message: "has boolean parameter 'bravo'",
-                           source: 'string',
-                           parameter: 'bravo')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      def alfa(bravo = true, charlie = true)
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:BooleanParameter, lines: [1], context: 'alfa', parameter: 'bravo').
-      and reek_of(:BooleanParameter, lines: [1], context: 'alfa', parameter: 'charlie')
-  end
-
-  context 'when examining an instance method' do
-    it 'reports a parameter defaulted to false' do
-      src = 'def alfa(bravo = false) end'
-      expect(src).to reek_of(:BooleanParameter)
-    end
-
-    it 'reports two parameters defaulted to booleans in a mixed parameter list' do
-      src = 'def alfa(bravo, charlie = true, delta = false, &echo) end'
-
-      expect(src).to reek_of(:BooleanParameter, parameter: 'charlie').
-        and reek_of(:BooleanParameter, parameter: 'delta').
-        and not_reek_of(:BooleanParameter, parameter: 'bravo').
-        and not_reek_of(:BooleanParameter, parameter: 'echo')
-    end
-
-    it 'reports keyword parameters defaulted to booleans' do
-      src = 'def alfa(bravo: true, charlie: false) end'
-      expect(src).
-        to reek_of(:BooleanParameter, parameter: 'bravo').
-        and reek_of(:BooleanParameter, parameter: 'charlie')
-    end
-
-    it 'does not report regular parameters' do
-      src = 'def alfa(bravo, charlie) end'
-      expect(src).not_to reek_of(:BooleanParameter)
-    end
-
-    it 'does not report array decomposition parameters' do
-      src = 'def alfa((bravo, charlie)) end'
-      expect(src).not_to reek_of(:BooleanParameter)
-    end
-
-    it 'does not report keyword parameters with no default' do
-      src = 'def alfa(bravo:, charlie:) end'
-      expect(src).not_to reek_of(:BooleanParameter)
-    end
-
-    it 'does not report keyword parameters with non-boolean default' do
-      src = 'def alfa(bravo: 42, charlie: "32") end'
-      expect(src).not_to reek_of(:BooleanParameter)
-    end
-  end
-
-  context 'when examining a singleton method' do
-    it 'reports a parameter defaulted to true' do
-      src = 'def self.alfa(bravo = true) end'
-      expect(src).to reek_of(:BooleanParameter)
-    end
-
-    it 'reports a parameter defaulted to false' do
-      src = 'def self.alfa(bravo = false) end'
-      expect(src).to reek_of(:BooleanParameter)
-    end
-
-    it 'reports two parameters defaulted to booleans' do
-      src = 'def self.alfa(bravo, charlie = true, delta = false, &echo) end'
-
-      expect(src).to reek_of(:BooleanParameter, parameter: 'charlie').
-        and reek_of(:BooleanParameter, parameter: 'delta').
-        and not_reek_of(:BooleanParameter, parameter: 'bravo').
-        and not_reek_of(:BooleanParameter, parameter: 'echo')
-    end
-  end
-end

data/spec/reek/smell_detectors/class_variable_spec.rb

@@ -1,106 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/class_variable'
-
-RSpec.describe Reek::SmellDetectors::ClassVariable do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        @@bravo = 5
-      end
-    RUBY
-
-    expect(src).to reek_of(:ClassVariable,
-                           lines:   [2],
-                           context: 'Alfa',
-                           message: "declares the class variable '@@bravo'",
-                           source:  'string',
-                           name:    '@@bravo')
-  end
-
-  it 'does count all class variables' do
-    src = <<-RUBY
-      class Alfa
-        @@bravo = 42
-        @@charlie = 99
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:ClassVariable, name: '@@bravo').
-      and reek_of(:ClassVariable, name: '@@charlie')
-  end
-
-  it 'does not report class instance variables' do
-    src = <<-RUBY
-      class Alfa
-        @bravo = 42
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:ClassVariable)
-  end
-
-  context 'with no class variables' do
-    it 'records nothing in the class' do
-      src = <<-RUBY
-        class Alfa
-          def bravo; end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:ClassVariable)
-    end
-
-    it 'records nothing in the module' do
-      src = <<-RUBY
-        module Alfa
-          def bravo; end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:ClassVariable)
-    end
-  end
-
-  ['class', 'module'].each do |scope|
-    context "when examining a #{scope}" do
-      it 'reports a class variable set in a method' do
-        src = <<-RUBY
-          #{scope} Alfa
-            def bravo
-              @@charlie = {}
-            end
-          end
-        RUBY
-
-        expect(src).to reek_of(:ClassVariable, name: '@@charlie')
-      end
-
-      it 'reports a class variable used in a method' do
-        src = <<-RUBY
-          #{scope} Alfa
-            def bravo
-              puts @@charlie
-            end
-          end
-        RUBY
-
-        expect(src).to reek_of(:ClassVariable, name: '@@charlie')
-      end
-
-      it "reports a class variable set in the #{scope} body and used in a method" do
-        src = <<-RUBY
-          #{scope} Alfa
-            @@bravo = 42
-
-            def charlie
-              puts @@bravo
-            end
-          end
-        RUBY
-
-        expect(src).to reek_of(:ClassVariable, name: '@@bravo')
-      end
-    end
-  end
-end

data/spec/reek/smell_detectors/control_parameter_spec.rb

@@ -1,300 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/control_parameter'
-
-RSpec.describe Reek::SmellDetectors::ControlParameter do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo ? true : false
-      end
-    RUBY
-
-    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 = <<-RUBY
-      def alfa(bravo, charlie)
-        bravo ? true : false
-        charlie ? true : false
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:ControlParameter, lines: [2], argument: 'bravo').
-      and reek_of(:ControlParameter, lines: [3], argument: 'charlie')
-  end
-
-  it 'does count multiple occurences of the same parameter' do
-    src = <<-RUBY
-      def alfa(bravo, charlie)
-        if bravo
-          delta if charlie
-        end
-        if charlie
-          delta if bravo
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:ControlParameter, lines: [2, 6], argument: 'bravo').
-      and reek_of(:ControlParameter, lines: [3, 5], argument: 'charlie')
-  end
-
-  context 'when a parameter is not used to determine code path' do
-    it 'does not report a ternary check on an ivar' do
-      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 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 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 alfa(bravo) if true then puts bravo end end'
-      expect(src).not_to reek_of(:ControlParameter)
-    end
-  end
-
-  context 'when a parameter is only used to determine code path' do
-    it 'reports a ternary check on a parameter' do
-      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 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 alfa(bravo); charlie if bravo; end'
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on an unless statement modifier' do
-      src = 'def alfa(bravo); charlie unless bravo; end'
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on if control expression' do
-      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 alfa(bravo); if bravo && true then charlie end; end'
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    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 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 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 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 alfa(bravo); if (bravo if true) then charlie end; end'
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on && notation' do
-      src = 'def alfa(bravo); bravo && charlie; end'
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on || notation' do
-      src = 'def alfa(bravo); bravo || charlie; end'
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on case statement' do
-      src = <<-RUBY
-        def alfa(bravo)
-          case bravo
-          when nil then nil
-          else false
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on nested if statements that are both using control parameters' do
-      src = <<-RUBY
-        def nested(bravo)
-          if bravo
-            charlie
-            charlie if bravo
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on nested suffix if statements where the inner if is a control parameter' do
-      src = <<-RUBY
-        def nested(bravo)
-          if true
-            charlie
-            charlie if bravo
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on nested full if statements where the inner if is a control parameter' do
-      src = <<-RUBY
-        def alfa(bravo)
-          if true
-            charlie
-          else
-            if bravo
-              delta
-            end
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on elsif statements' do
-      src = <<-RUBY
-        def alfa(bravo)
-          if true
-            charlie
-          elsif bravo
-            delta
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:ControlParameter)
-    end
-
-    it 'reports on explicit comparison in the condition' do
-      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 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 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 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 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 = 'def bravo(&charlie); delta(charlie || proc {}); end'
-      expect(src).to reek_of(:ControlParameter)
-    end
-  end
-
-  context 'when a parameter is used besides determining code path' do
-    it 'does not report on if conditional expression' do
-      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 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 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 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 alfa(bravo); bravo && charlie(bravo); end'
-      expect(src).not_to reek_of(:ControlParameter)
-    end
-
-    it 'does not report on || notation' do
-      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 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 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 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 = <<-RUBY
-        def alfa(bravo)
-          case bravo
-          when :charlie
-            puts 'charlie'
-          else
-            puts 'delta'
-          end
-          echo or foxtrot(bravo)
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:ControlParameter)
-    end
-  end
-end

data/spec/reek/smell_detectors/data_clump_spec.rb

@@ -1,134 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/data_clump'
-
-RSpec.describe Reek::SmellDetectors::DataClump do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo  (echo, foxtrot); end
-        def charlie(echo, foxtrot); end
-        def delta  (echo, foxtrot); end
-      end
-    RUBY
-
-    expect(src).to reek_of(:DataClump,
-                           lines:      [2, 3, 4],
-                           context:    'Alfa',
-                           message:    "takes parameters ['echo', 'foxtrot'] to 3 methods",
-                           source:     'string',
-                           parameters: ['echo', 'foxtrot'],
-                           count:      3)
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo  (echo, foxtrot); end
-        def charlie(echo, foxtrot); end
-        def delta  (echo, foxtrot); end
-
-        def golf (juliett, kilo); end
-        def hotel(juliett, kilo); end
-        def india(juliett, kilo); end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:DataClump, lines: [2, 3, 4], parameters: ['echo', 'foxtrot']).
-      and reek_of(:DataClump, lines: [6, 7, 8], parameters: ['juliett', 'kilo'])
-  end
-
-  %w(class module).each do |scope|
-    it "does not report parameter sets < 2 for #{scope}" do
-      src = <<-RUBY
-        #{scope} Alfa
-          def bravo  (echo); end
-          def charlie(echo); end
-          def delta  (echo); end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:DataClump)
-    end
-
-    it "does not report less than 3 methods for #{scope}" do
-      src = <<-RUBY
-        #{scope} Alfa
-          def bravo  (echo, foxtrot); end
-          def charlie(echo, foxtrot); end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:DataClump)
-    end
-
-    it 'does not care about the order of arguments' do
-      src = <<-RUBY
-        #{scope} Alfa
-          def bravo  (echo, foxtrot); end
-          def charlie(foxtrot, echo); end # <- This is the swapped one!
-          def delta  (echo, foxtrot); end
-        end
-      RUBY
-
-      expect(src).to reek_of(:DataClump,
-                             count: 3,
-                             parameters: ['echo', 'foxtrot'])
-    end
-
-    it 'reports arguments in alphabetical order even if they are never used that way' do
-      src = <<-RUBY
-        #{scope} Alfa
-          def bravo  (foxtrot, echo); end
-          def charlie(foxtrot, echo); end
-          def delta  (foxtrot, echo); end
-        end
-      RUBY
-
-      expect(src).to reek_of(:DataClump,
-                             count: 3,
-                             parameters: ['echo', 'foxtrot'])
-    end
-
-    it 'reports parameter sets that are > 2' do
-      src = <<-RUBY
-        #{scope} Alfa
-          def bravo  (echo, foxtrot, golf); end
-          def charlie(echo, foxtrot, golf); end
-          def delta  (echo, foxtrot, golf); end
-        end
-      RUBY
-
-      expect(src).to reek_of(:DataClump,
-                             count: 3,
-                             parameters: ['echo', 'foxtrot', 'golf'])
-    end
-
-    it 'detects clumps smaller than the total number of parameters' do
-      src = <<-RUBY
-        # Total number of parameters is 3 but the clump size is 2.
-        #{scope} Alfa
-          def bravo  (echo,  foxtrot, golf);    end
-          def charlie(echo,  golf,    foxtrot); end
-          def delta  (hotel, echo,    foxtrot); end
-        end
-      RUBY
-
-      expect(src).to reek_of(:DataClump,
-                             parameters: ['echo', 'foxtrot'])
-    end
-
-    it 'ignores anonymous parameters' do
-      src = <<-RUBY
-        #{scope} Alfa
-          def bravo  (echo, foxtrot, *); end
-          def charlie(echo, foxtrot, *); end
-          def delta  (echo, foxtrot, *); end
-        end
-      RUBY
-
-      expect(src).to reek_of(:DataClump,
-                             parameters: ['echo', 'foxtrot'])
-    end
-  end
-end