reek 6.0.2 → 6.1.4

data/spec/reek/smell_detectors/irresponsible_module_spec.rb

@@ -1,226 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/irresponsible_module'
-
-RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-      end
-    RUBY
-
-    expect(src).to reek_of(:IrresponsibleModule,
-                           lines:   [1],
-                           context: 'Alfa',
-                           message: 'has no descriptive comment',
-                           source:  'string')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        # Method is necessary because we don't count namespace classes.
-        def bravo; end
-        class Charlie
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:IrresponsibleModule, lines: [1], context: 'Alfa').
-      and reek_of(:IrresponsibleModule, lines: [4], context: 'Alfa::Charlie')
-  end
-
-  %w(class module).each do |scope|
-    it "reports a #{scope} without a comment" do
-      src = <<-RUBY
-        #{scope} Alfa
-        end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule)
-    end
-
-    it "does not report a #{scope} having a comment" do
-      src = <<-RUBY
-        # Do not report me, I'm responsible!
-        #{scope} Alfa; end
-      RUBY
-
-      expect(src).not_to reek_of(:IrresponsibleModule)
-    end
-
-    it "reports a #{scope} with an empty comment" do
-      src = <<-RUBY
-        #
-        #
-        #
-        #{scope} Alfa; end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule)
-    end
-
-    it "reports a #{scope} with a preceding comment with intermittent material" do
-      src = <<-RUBY
-        # This is a comment that should not be related to Bravo
-
-        require 'alfa'
-
-        #{scope} Bravo
-        end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule)
-    end
-
-    it "reports a #{scope} with only a trailing comment" do
-      src = <<-RUBY
-        #{scope} Alfa
-        end # This belongs to Alfa but doesn't count
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule)
-    end
-
-    it "does not report #{scope} used only as a namespace" do
-      src = <<-RUBY
-        #{scope} Alfa
-          # Describes Bravo
-          #{scope} Bravo
-            def charlie
-            end
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:IrresponsibleModule, context: 'Alfa')
-    end
-
-    it "does not report #{scope} used only as a namespace for several nested moduless" do
-      src = <<-RUBY
-        #{scope} Alfa
-          # Describes Bravo
-          class Bravo
-            def charlie
-            end
-          end
-
-          # Describes Delta
-          module Delta
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:IrresponsibleModule, context: 'Alfa')
-    end
-
-    it "reports #{scope} that is used as a namespace but also has methods" do
-      src = <<-RUBY
-        #{scope} Alfa
-          def bravo
-          end
-
-          # Describes Charlie
-          #{scope} Charlie
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
-    end
-
-    it "reports #{scope} that is used as a namespace but also has singleton methods" do
-      src = <<-RUBY
-        #{scope} Alfa
-          def self.bravo
-          end
-
-          # Describes Charlie
-          #{scope} Charlie
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
-    end
-
-    it "does not report a namespace #{scope} that has a nested class through assignment" do
-      src = <<-RUBY
-        #{scope} Alfa
-          # Bravo is responsible
-          Bravo = Class.new Charlie do
-            def delta; end
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:IrresponsibleModule, context: 'Alfa')
-    end
-
-    it "does not report #{scope} only containing constants" do
-      src = <<-RUBY
-        #{scope} Alfa
-          Bravo = 23
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:IrresponsibleModule, context: 'Alfa')
-    end
-
-    it "reports #{scope} that contains method calls" do
-      src = <<-RUBY
-        #{scope} Alfa
-          bravo :charlie
-        end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
-    end
-
-    it "reports #{scope} that contains non-constant assignments" do
-      src = <<-RUBY
-        #{scope} Alfa
-          bravo = charlie
-        end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
-    end
-
-    it "reports an irresponsible #{scope} defined through assignment" do
-      src = <<-RUBY
-        # Alfa is responsible, but Bravo is not
-        #{scope} Alfa
-          Bravo = Class.new Charlie # Only "class" is supposed to reek here.
-        end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa::Bravo')
-    end
-
-    it 'reports structs defined through assignment' do
-      src = <<-RUBY
-        # Alfa is responsible, but Bravo is not
-        #{scope} Alfa
-          Bravo = Struct.new(:charlie)
-        end
-      RUBY
-
-      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa::Bravo')
-    end
-
-    it 'does not report constants that are not classes' do
-      src = <<-RUBY
-        # Alfa is responsible
-        #{scope} Alfa
-          Bravo = 23
-          Charlie = Hash.new
-          Delta = ''.freeze
-          Echo = Class.new.new
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:IrresponsibleModule)
-    end
-  end
-end

data/spec/reek/smell_detectors/long_parameter_list_spec.rb

@@ -1,61 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/long_parameter_list'
-
-RSpec.describe Reek::SmellDetectors::LongParameterList do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie, delta, echo, foxtrot)
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:LongParameterList,
-                           lines:   [2],
-                           context: 'Alfa#bravo',
-                           message: 'has 4 parameters',
-                           source:  'string',
-                           count:   4)
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie, delta, echo, foxtrot)
-        end
-
-        def golf(hotel, india, juliett, kilo)
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:LongParameterList, lines: [2], context: 'Alfa#bravo').
-      and reek_of(:LongParameterList, lines: [5], context: 'Alfa#golf')
-  end
-
-  it 'reports nothing for 3 parameters' do
-    src = 'def alfa(bravo, charlie, delta); end'
-    expect(src).not_to reek_of(:LongParameterList)
-  end
-
-  it 'does not count an optional block' do
-    src = 'def alfa(bravo, charlie, delta, &block); end'
-    expect(src).not_to reek_of(:LongParameterList)
-  end
-
-  it 'does not report inner block with too many parameters' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.each { |charlie, delta, echo, foxtrot| }
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:LongParameterList)
-  end
-
-  it 'reports 4 parameters with default parameters' do
-    src = 'def alfa(bravo = 1, charlie = 2, delta = 3, echo = 4); end'
-    expect(src).to reek_of(:LongParameterList)
-  end
-end

data/spec/reek/smell_detectors/long_yield_list_spec.rb

@@ -1,49 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/long_yield_list'
-
-RSpec.describe Reek::SmellDetectors::LongYieldList do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie, delta, echo, foxtrot)
-          yield charlie, delta, echo, foxtrot
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:LongYieldList,
-                           lines:   [3],
-                           context: 'Alfa#bravo',
-                           message: 'yields 4 parameters',
-                           source:  'string',
-                           count:   4)
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie, delta, echo, foxtrot)
-          yield charlie, delta, echo, foxtrot
-        end
-
-        def golf(hotel, india, juliett, kilo)
-          yield hotel, india, juliett, kilo
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:LongYieldList, lines: [3], context: 'Alfa#bravo').
-      and reek_of(:LongYieldList, lines: [7], context: 'Alfa#golf')
-  end
-
-  it 'does not report yield with 3 parameters' do
-    src = <<-RUBY
-      def alfa(bravo, charlie, delta)
-        yield bravo, charlie, delta
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:LongYieldList)
-  end
-end

data/spec/reek/smell_detectors/manual_dispatch_spec.rb

@@ -1,75 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/too_many_constants'
-
-RSpec.describe Reek::SmellDetectors::ManualDispatch do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie)
-          true if charlie.respond_to?(:to_a)
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:ManualDispatch,
-                           lines:   [3],
-                           context: 'Alfa#bravo',
-                           message: 'manually dispatches method call',
-                           source:  'string')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie)
-          true if charlie.respond_to?(:to_a)
-        end
-
-        def delta(echo)
-          true if echo.respond_to?(:to_a)
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:ManualDispatch, lines: [3], context: 'Alfa#bravo').
-      and reek_of(:ManualDispatch, lines: [7], context: 'Alfa#delta')
-  end
-
-  it 'reports manual dispatch smell when using #respond_to? on implicit self' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          charlie if respond_to?(:delta)
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:ManualDispatch)
-  end
-
-  it 'reports manual dispatch within a conditional' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          charlie.respond_to?(:delta) && charlie.echo
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:ManualDispatch)
-  end
-
-  it 'reports occurences in a single method as one smell warning' do
-    src = <<-RUBY
-      class Alfa
-        def bravo(charlie, delta)
-          return true if charlie.respond_to?(:to_a)
-          true if delta.respond_to?(:to_a)
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:ManualDispatch, lines: [3, 4], context: 'Alfa#bravo')
-  end
-end

data/spec/reek/smell_detectors/missing_safe_method_spec.rb

@@ -1,68 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/missing_safe_method'
-
-RSpec.describe Reek::SmellDetectors::MissingSafeMethod do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo!
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:MissingSafeMethod,
-                           lines:   [2],
-                           context: 'Alfa',
-                           message: "has missing safe method 'bravo!'",
-                           source:  'string',
-                           name:    'bravo!')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo!
-        end
-
-        def charlie!
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:MissingSafeMethod, lines: [2], name: 'bravo!').
-      and reek_of(:MissingSafeMethod, lines: [5], name: 'charlie!')
-  end
-
-  it 'reports nothing when method and bang counterpart exist' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-        end
-
-        def bravo!
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:MissingSafeMethod)
-  end
-
-  it 'does not report methods we excluded via comment' do
-    source = <<-RUBY
-      # :reek:MissingSafeMethod { exclude: [ bravo! ] }
-      class Alfa
-        def bravo!
-        end
-
-        def charlie!
-        end
-      end
-    RUBY
-
-    aggregate_failures do
-      expect(source).not_to reek_of(:MissingSafeMethod, name: 'bravo!')
-      expect(source).to reek_of(:MissingSafeMethod, name: 'charlie!')
-    end
-  end
-end

data/spec/reek/smell_detectors/module_initialize_spec.rb

@@ -1,77 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/module_initialize'
-
-RSpec.describe Reek::SmellDetectors::ModuleInitialize do
-  it 'reports the right values' do
-    src = <<-RUBY
-      module Alfa
-        def initialize; end
-      end
-    RUBY
-
-    expect(src).to reek_of(:ModuleInitialize,
-                           lines:   [1],
-                           context: 'Alfa',
-                           message: 'has initialize method',
-                           source:  'string')
-  end
-
-  it 'reports nothing for a method with a different name' do
-    src = <<-RUBY
-      module Alfa
-        def bravo; end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:ModuleInitialize)
-  end
-
-  it 'reports nothing for a method named initialize in a nested class' do
-    src = <<-RUBY
-      module Alfa
-        class Bravo
-          def initialize; end
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:ModuleInitialize)
-  end
-
-  it 'reports nothing for a method named initialize in a nested struct' do
-    src = <<-RUBY
-      module Alfa
-        Bravo = Struct.new(:charlie) do
-          def initialize; end
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:ModuleInitialize)
-  end
-
-  it 'reports nothing for a method named initialize in a nested dynamic class' do
-    src = <<-RUBY
-      module Alfa
-        def self.bravo
-          Class.new do
-            def initialize; end
-          end
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:ModuleInitialize)
-  end
-
-  it 'can be disabled via comment' do
-    src = <<-RUBY
-      # :reek:ModuleInitialize
-      module Alfa
-        def initialize; end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:ModuleInitialize)
-  end
-end