reek 4.4.0 → 4.4.1

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -1,208 +1,191 @@
 require_relative '../../spec_helper'
-require_lib 'reek/context/code_context'
 require_lib 'reek/smells/irresponsible_module'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::IrresponsibleModule do
-  it 'reports a class without a comment' do
-    src = 'class BadClass; end'
-    expect(src).to reek_of :IrresponsibleModule,
-                           lines: [1],
-                           message: 'has no descriptive comment'
-  end
-
-  it 'reports a module without a comment' do
-    src = 'module BadClass; end'
-    expect(src).to reek_of(:IrresponsibleModule, context: 'BadClass')
-  end
-
-  it 'does not report re-opened modules' do
+  it 'reports the right values' do
     src = <<-EOS
-      # Abstract base class
-      class C; end
-
-      class C; def foo; end; end
+      class Alfa
+      end
     EOS
-    expect(src).not_to reek_of(:IrresponsibleModule)
-  end
 
-  it 'does not report a class having a comment' do
-    src = <<-EOS
-      # test class
-      class Responsible; end
-    EOS
-    expect(src).not_to reek_of(:IrresponsibleModule)
+    expect(src).to reek_of(:IrresponsibleModule,
+                           lines:   [1],
+                           context: 'Alfa',
+                           message: 'has no descriptive comment',
+                           source:  'string')
   end
 
-  it 'reports a class with an empty comment' do
+  it 'does count all occurences' do
     src = <<-EOS
-      #
-      #
-      #
-      class BadClass; end
+      class Alfa
+        # Method is necessary because we don't count empty classes.
+        def bravo; end
+        class Charlie
+        end
+      end
     EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'BadClass')
+
+    expect(src).to reek_of(:IrresponsibleModule,
+                           lines:   [1],
+                           context: 'Alfa')
+    expect(src).to reek_of(:IrresponsibleModule,
+                           lines:   [4],
+                           context: 'Alfa::Charlie')
   end
 
-  it 'reports a class with a preceding comment with intermittent material' do
-    src = <<-EOS
-      # This is a valid comment
+  %w(class module).each do |scope|
+    it "reports a #{scope} without a comment" do
+      src = <<-EOS
+        #{scope} Alfa
+        end
+      EOS
 
-      require 'foo'
+      expect(src).to reek_of(:IrresponsibleModule)
+    end
 
-      class Bar; end
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Bar')
-  end
+    it "does not report re-opened #{scope}" do
+      src = <<-EOS
+        # Abstract base
+        #{scope} Alfa; end
 
-  it 'reports a class with a trailing comment' do
-    src = <<-EOS
-      class BadClass
-      end # end BadClass
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'BadClass')
-  end
+        #{scope} Alfa; def bravo; end; end
+      EOS
 
-  it 'reports a fully qualified class name correctly' do
-    src = 'class Foo::Bar; end'
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo::Bar')
-  end
+      expect(src).not_to reek_of(:IrresponsibleModule)
+    end
 
-  it 'does not report modules used only as namespaces' do
-    src = <<-EOS
-      module Foo
-        # Describes Bar
-        class Bar
-          def baz
+    it "does not report a #{scope} having a comment" do
+      src = <<-EOS
+        # Do not report me
+        #{scope} Alfa; end
+      EOS
+
+      expect(src).not_to reek_of(:IrresponsibleModule)
+    end
+
+    it "reports a #{scope} with an empty comment" do
+      src = <<-EOS
+        #
+        #
+        #
+        #{scope} Alfa; end
+      EOS
+
+      expect(src).to reek_of(:IrresponsibleModule)
+    end
+
+    it "reports a #{scope} with a preceding comment with intermittent material" do
+      src = <<-EOS
+        # This is a valid comment
+
+        require 'alfa'
+
+        #{scope} Bravo
+        end
+      EOS
+
+      expect(src).to reek_of(:IrresponsibleModule)
+    end
+
+    it "reports a #{scope} with only a trailing comment" do
+      src = <<-EOS
+        #{scope} Alfa
+        end # end scope
+      EOS
+
+      expect(src).to reek_of(:IrresponsibleModule)
+    end
+
+    it "does not report #{scope} used only as namespaces" do
+      src = <<-EOS
+        #{scope} Alfa
+          # Describes Bravo
+          #{scope} Bravo
+            def charlie
+            end
           end
         end
-      end
-    EOS
-    expect(src).not_to reek_of(:IrresponsibleModule)
-  end
+      EOS
 
-  it 'does not report classes used only as namespaces' do
-    src = <<-EOS
-      class Foo
-        # Describes Bar
-        module Bar
-          def qux
+      expect(src).not_to reek_of(:IrresponsibleModule)
+    end
+
+    it "reports #{scope} that have both a nested #{scope} and methods" do
+      src = <<-EOS
+        #{scope} Alfa
+          def bravo
           end
-        end
-      end
-    EOS
-    expect(src).not_to reek_of(:IrresponsibleModule)
-  end
 
-  it 'reports modules that have both nested modules and methods' do
-    src = <<-EOS
-      module Foo
-        def foofoo
-        end
-        # Describes Bar
-        module Bar
+          # Describes Charlie
+          #{scope} Charlie
+          end
         end
-      end
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
-  end
+      EOS
 
-  it 'reports modules that have both nested modules and singleton methods' do
-    src = <<-EOS
-      module Foo
-        def self.foofoo
-        end
-        # Describes Bar
-        module Bar
-        end
-      end
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
-  end
+      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
+    end
 
-  it 'reports modules that have both nested modules and methods on the singleton class' do
-    src = <<-EOS
-      module Foo
-        class << self
-          def foofoo
+    it "reports #{scope} that has both a nested #{scope} and singleton methods" do
+      src = <<-EOS
+        #{scope} Alfa
+          def self.bravo
           end
-        end
-        # Describes Bar
-        module Bar
-        end
-      end
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
-  end
 
-  it 'does not report namespace modules that have a nested class through assignment' do
-    src = <<-EOS
-      module Qux
-        # Foo is responsible
-        Foo = Class.new Bar do
-          def quux; end
+          # Describes Charlie
+          #{scope} Charlie
+          end
         end
-      end
-    EOS
-    expect(src).not_to reek_of(:IrresponsibleModule)
-  end
+      EOS
 
-  it 'reports classes that have a defined superclass' do
-    src = <<-EOS
-      class Foo < Bar; end
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
-  end
+      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
+    end
 
-  it 'reports classes defined through assignment' do
-    src = <<-EOS
-      # Qux is responsible, but Foo is not
-      module Qux
-        Foo = Class.new Bar
-      end
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Qux::Foo')
-  end
-
-  it 'reports top level classes defined through assignment' do
-    src = <<-EOS
-      Foo = Class.new Bar
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
-  end
+    it "does not report a namespace #{scope} that has a nested class through assignment" do
+      src = <<-EOS
+        #{scope} Alfa
+          # Bravo is responsible
+          Bravo = Class.new Charlie do
+            def delta; end
+          end
+        end
+      EOS
 
-  it 'reports structs defined through assignment' do
-    src = <<-EOS
-      # Qux is responsible, but Foo is not
-      module Qux
-        Foo = Struct.new(:x, :y)
-      end
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Qux::Foo')
-  end
+      expect(src).not_to reek_of(:IrresponsibleModule)
+    end
 
-  it 'reports top level structs defined through assignment' do
-    src = <<-EOS
-      Foo = Struct.new(:x, :y)
-    EOS
-    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
-  end
+    it "reports a #{scope} defined through assignment" do
+      src = <<-EOS
+        # Alfa is responsible, but Bravo is not
+        #{scope} Alfa
+          Bravo = Class.new Charlie # Only "class" is supposed to reek here.
+        end
+      EOS
 
-  it 'does not report constants that are not classes' do
-    src = <<-EOS
-      module Qux
-        Foo = 23
-        Bar = Hash.new
-        Quuz = 'foo'.freeze
-        Zyxxy = Class.new.new
-      end
-    EOS
-    expect(src).not_to reek_of(:IrresponsibleModule)
-  end
+      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa::Bravo')
+    end
 
-  context 'when a smell is reported' do
-    let(:detector) { build(:smell_detector, smell_type: :IrresponsibleModule) }
+    it 'reports structs defined through assignment' do
+      src = <<-EOS
+        # Alfa is responsible, but Bravo is not
+        #{scope} Alfa
+          Bravo = Struct.new(:charlie)
+        end
+      EOS
+
+      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa::Bravo')
+    end
+
+    it 'does not report constants that are not classes' do
+      src = <<-EOS
+        #{scope} Alfa
+          Bravo = 23
+          Charlie = Hash.new
+          Delta = ''.freeze
+          Echo = Class.new.new
+        end
+      EOS
 
-    it_should_behave_like 'SmellDetector'
+      expect(src).not_to reek_of(:IrresponsibleModule)
+    end
   end
 end

data/spec/reek/smells/long_parameter_list_spec.rb

@@ -1,107 +1,63 @@
 require_relative '../../spec_helper'
-require_lib 'reek/context/code_context'
 require_lib 'reek/smells/long_parameter_list'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::LongParameterList do
-  context 'for methods with few parameters' do
-    it 'should report nothing for no parameters' do
-      expect('def simple; f(3);true; end').not_to reek_of(:LongParameterList)
-    end
-
-    it 'should report nothing for 1 parameter' do
-      expect('def simple(yep) f(3);true end').not_to reek_of(:LongParameterList)
-    end
-
-    it 'should report nothing for 2 parameters' do
-      expect('def simple(yep,zero) f(3);true end').not_to reek_of(:LongParameterList)
-    end
-
-    it 'should not count an optional block' do
-      src = 'def simple(alpha, yep, zero, &opt) f(3); true end'
-      expect(src).not_to reek_of(:LongParameterList)
-    end
-
-    it 'should not report inner block with too many parameters' do
-      src = '
-        def simple(yep,zero)
-          m[3]; rand(34); f.each { |arga, argb, argc, argd| true}
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        def bravo(charlie, delta, echo, foxtrot)
         end
-      '
-      expect(src).not_to reek_of(:LongParameterList)
-    end
-
-    describe 'and default values' do
-      it 'should report nothing for 1 parameter' do
-        expect('def simple(zero=nil) f(3);false end').not_to reek_of(:LongParameterList)
       end
+    EOS
+
+    expect(src).to reek_of(:LongParameterList,
+                           lines:   [2],
+                           context: 'Alfa#bravo',
+                           message: 'has 4 parameters',
+                           source:  'string',
+                           count:   4)
+  end
 
-      it 'should report nothing for 2 parameters with 1 default' do
-        source = 'def simple(yep, zero=nil) f(3); false end'
-        expect(source).not_to reek_of(:LongParameterList)
-      end
+  it 'does count all occurences' do
+    src = <<-EOS
+      class Alfa
+        def bravo(charlie, delta, echo, foxtrot)
+        end
 
-      it 'should report nothing for 2 defaulted parameters' do
-        source = 'def simple(yep=4, zero=nil) f(3); false end'
-        expect(source).not_to reek_of(:LongParameterList)
+        def golf(hotel, india, juliett, kilo)
+        end
       end
-    end
+    EOS
+
+    expect(src).to reek_of(:LongParameterList,
+                           lines:   [2],
+                           context: 'Alfa#bravo')
+    expect(src).to reek_of(:LongParameterList,
+                           lines:   [5],
+                           context: 'Alfa#golf')
   end
 
-  describe 'for methods with too many parameters' do
-    it 'should report 4 parameters' do
-      src = 'def simple(arga, argb, argc, argd) f(3);true end'
-      expect(src).to reek_of(:LongParameterList, count: 4)
-    end
+  it 'reports nothing for 3 parameters' do
+    expect('def alfa(bravo, charlie, delta); end').not_to reek_of(:LongParameterList)
+  end
 
-    it 'should report 8 parameters' do
-      src = 'def simple(arga, argb, argc, argd,arge, argf, argg, argh) f(3);true end'
-      expect(src).to reek_of(:LongParameterList, count: 8)
-    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
 
-    describe 'and default values' do
-      it 'should report 3 with 1 defaulted' do
-        src = 'def simple(polly, queue, yep, zero=nil) f(3);false end'
-        expect(src).to reek_of(:LongParameterList, count: 4)
+  it 'does not report inner block with too many parameters' do
+    src = <<-EOS
+      def alfa(bravo)
+        bravo.each { |charlie, delta, echo, foxtrot| }
       end
+    EOS
 
-      it 'should report with 3 defaulted' do
-        src = 'def simple(aarg, polly=2, yep=:truth, zero=nil) f(3);false end'
-        expect(src).to reek_of(:LongParameterList, count: 4)
-      end
-    end
+    expect(src).not_to reek_of(:LongParameterList)
   end
-end
-
-RSpec.describe Reek::Smells::LongParameterList do
-  let(:detector) { build(:smell_detector, smell_type: :LongParameterList) }
-
-  it_should_behave_like 'SmellDetector'
-
-  context 'when a smell is reported' do
-    let(:warning) do
-      src = <<-EOS
-        def badguy(arga, argb, argc, argd)
-          f(3)
-          true
-        end
-      EOS
-      ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector.sniff(ctx).first
-    end
-
-    it_should_behave_like 'common fields set correctly'
-
-    it 'reports the number of parameters' do
-      expect(warning.parameters[:count]).to eq(4)
-    end
-
-    it 'reports the line number of the method' do
-      expect(warning.lines).to eq([1])
-    end
 
-    it 'has the right message' do
-      expect(warning.message).to eq('has 4 parameters')
-    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