reek 6.0.2 → 6.2.0

data/spec/reek/smell_detectors/duplicate_method_call_spec.rb

@@ -1,211 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/duplicate_method_call'
-
-RSpec.describe Reek::SmellDetectors::DuplicateMethodCall do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie)
-          charlie.delta
-          charlie.delta
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:DuplicateMethodCall,
-                           lines:   [3, 4],
-                           context: 'Alfa#bravo',
-                           message: "calls 'charlie.delta' 2 times",
-                           source:  'string',
-                           name:    'charlie.delta',
-                           count:   2)
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie)
-          charlie.delta
-          charlie.delta
-        end
-
-        def echo(foxtrot)
-          foxtrot.golf
-          foxtrot.golf
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:DuplicateMethodCall, lines: [3, 4], name: 'charlie.delta', count: 2).
-      and reek_of(:DuplicateMethodCall, lines: [8, 9], name: 'foxtrot.golf', count: 2)
-  end
-
-  context 'with repeated method calls' do
-    it 'reports repeated call to lvar' do
-      src = 'def alfa(bravo); bravo.charlie + bravo.charlie; end'
-      expect(src).to reek_of(:DuplicateMethodCall, name: 'bravo.charlie')
-    end
-
-    it 'reports call parameters' do
-      src = 'def alfa; @bravo.charlie(2, 3) + @bravo.charlie(2, 3); end'
-      expect(src).to reek_of(:DuplicateMethodCall, name: '@bravo.charlie(2, 3)')
-    end
-
-    it 'reports nested calls' do
-      src = 'def alfa; @bravo.charlie.delta + @bravo.charlie.delta; end'
-      expect(src).
-        to reek_of(:DuplicateMethodCall, name: '@bravo.charlie').
-        and reek_of(:DuplicateMethodCall, name: '@bravo.charlie.delta')
-    end
-
-    it 'ignores calls to new' do
-      src = 'def alfa; @bravo.new + @bravo.new; end'
-      expect(src).not_to reek_of(:DuplicateMethodCall)
-    end
-  end
-
-  context 'with repeated simple method calls' do
-    it 'reports no smell' do
-      src = <<-RUBY
-        def alfa
-          bravo
-          bravo
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:DuplicateMethodCall)
-    end
-  end
-
-  context 'with repeated simple method calls with blocks' do
-    it 'reports a smell if the blocks are identical' do
-      src = <<-RUBY
-        def alfa
-          bravo { charlie }
-          bravo { charlie }
-        end
-      RUBY
-
-      expect(src).to reek_of(:DuplicateMethodCall)
-    end
-
-    it 'reports no smell if the blocks are different' do
-      src = <<-RUBY
-        def alfa
-          bravo { charlie }
-          bravo { delta }
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:DuplicateMethodCall)
-    end
-  end
-
-  context 'with repeated method calls with receivers with blocks' do
-    it 'reports a smell if the blocks are identical' do
-      src = <<-RUBY
-        def alfa
-          bravo.charlie { delta }
-          bravo.charlie { delta }
-        end
-      RUBY
-
-      expect(src).to reek_of(:DuplicateMethodCall)
-    end
-
-    it 'reports a smell if the blocks are different' do
-      src = <<-RUBY
-        def alfa
-          bravo.charlie { delta }
-          bravo.charlie { echo }
-        end
-      RUBY
-
-      expect(src).to reek_of(:DuplicateMethodCall)
-    end
-  end
-
-  context 'with repeated attribute assignment' do
-    it 'reports repeated assignment' do
-      src = <<-RUBY
-        def alfa(bravo)
-          @charlie[bravo] = true
-          @charlie[bravo] = true
-        end
-      RUBY
-
-      expect(src).to reek_of(:DuplicateMethodCall)
-    end
-
-    it 'does not report multi-assignments' do
-      src = <<-RUBY
-        def alfa
-          bravo, charlie = delta, echo
-          charlie, bravo = delta, echo
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:DuplicateMethodCall)
-    end
-  end
-
-  context 'with non-repeated method calls' do
-    it 'does not report similar calls' do
-      src = 'def alfa(bravo) bravo.charlie == self.charlie end'
-      expect(src).not_to reek_of(:DuplicateMethodCall)
-    end
-
-    it 'respects call parameters' do
-      src = 'def alfa; @bravo.charlie(3) + @bravo.charlie(2) end'
-      expect(src).not_to reek_of(:DuplicateMethodCall)
-    end
-  end
-
-  context 'when allowing up to 3 calls' do
-    let(:config) do
-      { Reek::SmellDetectors::DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 }
-    end
-
-    it 'does not report double calls' do
-      src = 'def alfa(bravo); bravo.charlie + bravo.charlie; end'
-      expect(src).not_to reek_of(:DuplicateMethodCall).with_config(config)
-    end
-
-    it 'does not report triple calls' do
-      src = 'def alfa(bravo); bravo.charlie + bravo.charlie + bravo.charlie; end'
-      expect(src).not_to reek_of(:DuplicateMethodCall).with_config(config)
-    end
-
-    it 'reports quadruple calls' do
-      src = <<-RUBY
-        def alfa
-          bravo.charlie + bravo.charlie + bravo.charlie + bravo.charlie
-        end
-      RUBY
-
-      expect(src).to reek_of(:DuplicateMethodCall,
-                             count: 4).with_config(config)
-    end
-  end
-
-  context 'when allowing calls to some methods' do
-    it 'does not report calls to some methods' do
-      config = { Reek::SmellDetectors::DuplicateMethodCall::ALLOW_CALLS_KEY => ['@bravo.charlie'] }
-      src = 'def alfa; @bravo.charlie + @bravo.charlie; end'
-      expect(src).not_to reek_of(:DuplicateMethodCall).with_config(config)
-    end
-
-    it 'reports calls to other methods' do
-      config = { Reek::SmellDetectors::DuplicateMethodCall::ALLOW_CALLS_KEY => ['@delta.charlie'] }
-      src = 'def alfa; @bravo.charlie + @bravo.charlie; end'
-      expect(src).to reek_of(:DuplicateMethodCall, name: '@bravo.charlie').with_config(config)
-    end
-
-    it 'does not report calls to methods specifed with a regular expression' do
-      config = { Reek::SmellDetectors::DuplicateMethodCall::ALLOW_CALLS_KEY => [/charlie/] }
-      src = 'def alfa; puts @bravo.charlie; puts @bravo.charlie; end'
-      expect(src).not_to reek_of(:DuplicateMethodCall, name: '@bravo.charlie').with_config(config)
-    end
-  end
-end

data/spec/reek/smell_detectors/feature_envy_spec.rb

@@ -1,295 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/feature_envy'
-
-RSpec.describe Reek::SmellDetectors::FeatureEnvy do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie)
-          (charlie.delta - charlie.echo) * foxtrot
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:FeatureEnvy,
-                           lines:   [3, 3],
-                           context: 'Alfa#bravo',
-                           message: "refers to 'charlie' more than self (maybe move it to another class?)",
-                           source:  'string',
-                           name:    'charlie')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie)
-          (charlie.delta - charlie.echo) * foxtrot
-        end
-
-        def golf(hotel)
-          (hotel.india + hotel.juliett) * kilo
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:FeatureEnvy, lines: [3, 3], name: 'charlie').
-      and reek_of(:FeatureEnvy, lines: [7, 7], name: 'hotel')
-  end
-
-  it 'does not report use of self' do
-    src = 'def alfa; self.to_s + self.to_i; end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report vcall with no argument' do
-    src = 'def alfa; bravo; end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report single use' do
-    src = 'def alfa(bravo); bravo.charlie(@delta); end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report return value' do
-    src = 'def alfa(bravo); bravo.charlie(@delta); bravo; end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does ignore global variables' do
-    src = 'def alfa; $bravo.to_a; $bravo[@charlie]; end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report class methods' do
-    src = 'def alfa; self.class.bravo(self); end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report single use of an ivar' do
-    src = 'def alfa; @bravo.to_a; end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report returning an ivar' do
-    src = 'def alfa; @bravo.to_a; @bravo; end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report ivar usage in a parameter' do
-    src = 'def alfa; @bravo.charlie + delta(@bravo) - echo(@bravo) end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report single use of an lvar' do
-    src = 'def alfa; bravo = @charlie; bravo.to_a; end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report returning an lvar' do
-    src = 'def alfa; bravo = @charlie; bravo.to_a; lv end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'ignores lvar usage in a parameter' do
-    src = 'def alfa; bravo = @item; bravo.charlie + delta(bravo) - echo(bravo); end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report parameter method called with super' do
-    src = 'def alfa(bravo) super(bravo.to_s); end'
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'reports parameter method called with super and elsewhere' do
-    src = 'def alfa(bravo) bravo.charley; super(bravo.to_s); end'
-    expect(src).to reek_of(:FeatureEnvy)
-  end
-
-  it 'ignores multiple ivars' do
-    src = <<-RUBY
-      def func
-        @alfa.charlie
-        @alfa.delta
-
-        @bravo.echo
-        @bravo.foxtrot
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'report highest affinity' do
-    src = <<-RUBY
-      def alfa
-        bravo = @charlie
-        delta = 0
-        delta += bravo.echo
-        delta += bravo.foxtrot
-        delta *= 1.15
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:FeatureEnvy, name: 'delta').
-      and not_reek_of(:FeatureEnvy, name: 'bravo')
-  end
-
-  it 'reports multiple affinities' do
-    src = <<-RUBY
-      def alfa
-        bravo = @charlie
-        delta = 0
-        delta += bravo.echo
-        delta += bravo.foxtrot
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:FeatureEnvy, name: 'delta').
-      and reek_of(:FeatureEnvy, name: 'bravo')
-  end
-
-  it 'is not fooled by duplication' do
-    src = <<-RUBY
-      def alfa(bravo)
-        @charlie.delta(bravo.echo)
-        @foxtrot.delta(bravo.echo)
-      end
-    RUBY
-
-    expect(src).to reek_only_of(:DuplicateMethodCall, name: 'bravo.echo')
-  end
-
-  it 'counts local calls' do
-    src = <<-RUBY
-      def alfa(bravo)
-        charlie.delta(bravo.echo)
-        foxtrot.delta(bravo.echo)
-      end
-    RUBY
-
-    expect(src).to reek_only_of(:DuplicateMethodCall, name: 'bravo.echo')
-  end
-
-  it 'reports many calls to lvar' do
-    src = <<-RUBY
-      def alfa
-        bravo = @charlie
-        bravo.delta + bravo.echo
-      end
-    RUBY
-
-    expect(src).to reek_only_of(:FeatureEnvy)
-  end
-
-  it 'counts =~ as a call' do
-    src = <<-RUBY
-      def alfa(bravo)
-        charlie(bravo.delta)
-        bravo =~ /charlie/
-      end
-    RUBY
-
-    expect(src).to reek_of :FeatureEnvy
-  end
-
-  it 'counts += as a call' do
-    src = <<-RUBY
-      def alfa(bravo)
-        charlie(bravo.delta)
-        bravo += 1
-      end
-    RUBY
-
-    expect(src).to reek_of :FeatureEnvy
-  end
-
-  it 'counts ivar assignment as call to self' do
-    src = <<-RUBY
-      def foo
-        bravo = charlie(1, 2)
-
-        @delta = bravo.echo
-        @foxtrot = bravo.golf
-      end
-    RUBY
-
-    expect(src).not_to reek_of :FeatureEnvy
-  end
-
-  it 'counts self references correctly' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.keys.each do |charlie|
-          self[charlie] += 3
-          self[charlie] = 4
-        end
-        self
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'interprets << correctly' do
-    src = <<-RUBY
-      def alfa(bravo)
-        if @charlie
-          bravo.delta(self)
-        else
-          bravo << self
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report on class methods defined by opening the metaclass' do
-    src = <<-RUBY
-      class Alfa
-        class << self
-          def bravo(charlie)
-            delta = new(charlie)
-            delta.echo
-            delta.echo
-          end
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report on class methods defined with an explicit receiver' do
-    src = <<-RUBY
-      class Alfa
-        def self.bravo(charlie)
-          delta = new(charlie)
-          delta.echo
-          delta.echo
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-
-  it 'does not report module functions' do
-    src = <<-RUBY
-      module Alfa
-        module_function
-        def bravo(charlie)
-          echo = delta(charlie)
-          echo.foxtrot
-          echo.foxtrot
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
-end

data/spec/reek/smell_detectors/instance_variable_assumption_spec.rb

@@ -1,96 +0,0 @@
-require_relative '../../spec_helper'
-
-require_lib 'reek/smell_detectors/instance_variable_assumption'
-
-RSpec.describe Reek::SmellDetectors::InstanceVariableAssumption do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          @charlie
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:InstanceVariableAssumption,
-                           lines:      [1],
-                           context:    'Alfa',
-                           message:    "assumes too much for instance variable '@charlie'",
-                           source:     'string',
-                           assumption: '@charlie')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          @charlie
-        end
-
-        def delta
-          @echo
-        end
-      end
-
-    RUBY
-
-    expect(src).
-      to reek_of(:InstanceVariableAssumption, lines: [1], assumption: '@charlie').
-      and reek_of(:InstanceVariableAssumption, lines: [1], assumption: '@echo')
-  end
-
-  it 'does not report an empty class' do
-    src = <<-RUBY
-      class Alfa
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:InstanceVariableAssumption)
-  end
-
-  it 'does not report when lazy initializing' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          @charlie ||= 1
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:InstanceVariableAssumption)
-  end
-
-  it 'reports variable even if others are initialized' do
-    src = <<-RUBY
-      class Alfa
-        def initialize
-          @bravo = 1
-        end
-
-        def charlie
-          [@bravo, @delta]
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:InstanceVariableAssumption, assumption: '@delta')
-  end
-
-  it 'reports inner class even if outer class initializes the variable' do
-    src = <<-RUBY
-      class Alfa
-        def initialize
-          @bravo = 1
-        end
-
-        class Charlie
-          def delta
-            @bravo
-          end
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:InstanceVariableAssumption, context: 'Alfa::Charlie')
-  end
-end