reek 4.4.0 → 4.4.1

data/spec/reek/smells/too_many_constants_spec.rb

@@ -1,234 +1,144 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/too_many_constants'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::TooManyConstants do
-  context 'counting constants' do
-    it 'should not report for non-excessive constants' do
-      src = <<-EOS
-        class Dummy
-          A = B = C = D = E = 1
-        end
-      EOS
-
-      expect(src).not_to reek_of(:TooManyConstants)
-    end
-
-    it 'should not report when increasing default' do
-      src = <<-EOS
-        # :reek:TooManyConstants: { max_constants: 6 }
-        class Dummy
-          A = B = C = D = E = 1
-          F = 1
-        end
-      EOS
+  let(:config) do
+    { Reek::Smells::TooManyConstants::MAX_ALLOWED_CONSTANTS_KEY => 2 }
+  end
 
-      expect(src).not_to reek_of(:TooManyConstants)
-    end
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        Bravo = Charlie = Delta = 1
+      end
+    EOS
+
+    expect(src).to reek_of(:TooManyConstants,
+                           lines:   [1],
+                           context: 'Alfa',
+                           message: 'has 3 constants',
+                           source:  'string',
+                           count:   3).with_config(config)
+  end
 
-    it 'should not report when disabled' do
-      src = <<-EOS
-        # :reek:TooManyConstants: { enabled: false }
-        class Dummy
-          A = B = C = D = E = 1
-          F = 1
-        end
-      EOS
+  it 'should not report for non-excessive constants' do
+    src = <<-EOS
+      class Alfa
+        Bravo = Charlie = 1
+      end
+    EOS
 
-      expect(src).not_to reek_of(:TooManyConstants)
-    end
+    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
+  end
 
-    it 'should not account class definition' do
-      src = <<-EOS
-        module Dummiest
-          class Dummy
-            A = B = C = D = E = 1
+  it 'should not report when increasing default' do
+    src = <<-EOS
+      # :reek:TooManyConstants: { max_constants: 3 }
+      class Alfa
+        Bravo = Charlie = Delta = 1
+      end
+    EOS
 
-            Error = Class.new(StandardError)
-          end
-        end
-      EOS
+    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
+  end
 
-      expect(src).not_to reek_of(:TooManyConstants)
-    end
+  it 'should not report when disabled' do
+    src = <<-EOS
+      # :reek:TooManyConstants: { enabled: false }
+      class Alfa
+        Bravo = Charlie = Delta = 1
+      end
+    EOS
 
-    it 'should not account struct definition' do
-      src = <<-EOS
-        module Dummiest
-          class Dummy
-            A = B = C = D = E = 1
+    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
+  end
 
-            Struct = Struct.new
-          end
-        end
-      EOS
+  it 'should not account class definition' do
+    src = <<-EOS
+      class Alfa
+        Bravo = Charlie = 1
+        Delta = Class.new(StandardError)
+      end
+    EOS
 
-      expect(src).to_not reek_of(:TooManyConstants)
-    end
+    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
+  end
 
-    it 'should count each constant only once' do
-      src = <<-EOS
-        class Good
-          A = B = C = D = E = 1
-        end
+  it 'should not account struct definition' do
+    src = <<-EOS
+      class Alfa
+        Bravo = Charlie = 1
+        Delta = Struct.new
+      end
+    EOS
 
-        class Bad
-          A = B = C = D = E = 1
-        end
+    expect(src).to_not reek_of(:TooManyConstants).with_config(config)
+  end
 
-        class Ugly
-          A = B = C = D = E = 1
-        end
-      EOS
+  it 'should count each constant only once' do
+    src = <<-EOS
+      class Alfa
+        Bravo = Charlie = 1
+      end
 
-      expect(src).not_to reek_of(:TooManyConstants)
-    end
+      class Delta
+        Echo = Foxtrot = 1
+      end
 
-    it 'should count each constant only once for each class' do
-      src = <<-EOS
-        module Movie
-          class Good
-            A = B = C = D = E = 1
-          end
+      class Golf
+        Hotel = India = 1
+      end
+    EOS
 
-          class Bad
-            F = G = H = I = J = 1
-          end
+    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
+  end
 
-          class Ugly
-            K = L = M = N = O = 1
-          end
-        end
-      EOS
-
-      expect(src).not_to reek_of(:TooManyConstants)
-    end
-
-    it 'should not report outer module when inner module suppressed' do
-      src = <<-EOS
-        module Foo
-          # ignore :reek:TooManyConstants:
-          module Bar
-            A = 1
-            B = 2
-            C = 3
-            D = 4
-            E = 5
-            F = 6
-          end
+  it 'should not report outer module when inner module suppressed' do
+    src = <<-EOS
+      module Alfa
+        # ignore :reek:TooManyConstants:
+        module Bravo
+          Charlie = Delta = Echo = 1
         end
-      EOS
-
-      expect(src).not_to reek_of(:TooManyConstants, context: 'Foo')
-    end
-
-    it 'should count each constant only once for each namespace' do
-      src = <<-EOS
-        module Movie
-          A = B = C = D = E = 1
+      end
+    EOS
 
-          class Good
-            F = 1
-          end
-        end
-      EOS
+    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
+  end
 
-      expect(src).not_to reek_of(:TooManyConstants)
-    end
+  it 'should count each constant only once for each namespace' do
+    src = <<-EOS
+      module Alfa
+        Bravo = Charlie = 1
 
-    it 'should report for excessive constants inside a class' do
-      src = <<-EOS
-        class Dummy
-          A = B = C = D = E = 1
-          F = 1
+        class Delta
+          Echo = 1
         end
-      EOS
-
-      expect(src).to reek_of(:TooManyConstants)
-    end
+      end
+    EOS
 
-    it 'should report for excessive constants inside a module' do
-      src = <<-EOS
-        module Dummiest
-          A = B = C = D = E = 1
-          F = 1
+    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
+  end
 
-          class Dummy
-          end
-        end
-      EOS
+  it 'should report for excessive constants inside a module' do
+    src = <<-EOS
+      module Alfa
+        Bravo = Charlie = Delta = 1
+      end
+    EOS
 
-      expect(src).to reek_of(:TooManyConstants, context: 'Dummiest')
-    end
+    expect(src).to reek_of(:TooManyConstants, context: 'Alfa').with_config(config)
   end
 
-  context 'smell report' do
-    it 'reports the number of constants' do
-      src = <<-EOS
-        module Moduly
-          class Klass
-            A = B = C = D = E = 1
-            F = 1
-          end
+  it 'reports the full class name' do
+    src = <<-EOS
+      module Alfa
+        class Bravo
+          Charlie = Delta = Echo = 1
         end
-      EOS
-
-      expect(src).to reek_of(:TooManyConstants, count: 6)
-    end
-
-    it 'reports the line where it occurs' do
-      src = <<-EOS
-        module Moduly
-          class Klass
-            A = B = C = D = E = 1
-            F = 1
-          end
-        end
-      EOS
-
-      expect(src).to reek_of(:TooManyConstants, lines: [2])
-    end
-
-    it 'reports a readable message' do
-      src = <<-EOS
-        module Moduly
-          class Klass
-            A = B = C = D = E = 1
-            F = 1
-          end
-        end
-      EOS
-
-      expect(src).to reek_of(:TooManyConstants, message: 'has 6 constants')
-    end
-
-    context 'context' do
-      it 'reports the full class name' do
-        src = <<-EOS
-          module Moduly
-            class Klass
-              A = B = C = D = E = 1
-              F = 1
-            end
-          end
-        EOS
-
-        expect(src).to reek_of(:TooManyConstants, context: 'Moduly::Klass')
       end
+    EOS
 
-      it 'reports the module name' do
-        src = <<-EOS
-          module Moduly
-            A = B = C = D = E = 1
-            F = 1
-
-            class Klass
-            end
-          end
-        EOS
-
-        expect(src).to reek_of(:TooManyConstants, context: 'Moduly')
-      end
-    end
+    expect(src).to reek_of(:TooManyConstants, context: 'Alfa::Bravo').with_config(config)
   end
 end

data/spec/reek/smells/too_many_instance_variables_spec.rb

@@ -2,154 +2,131 @@ require_relative '../../spec_helper'
 require_lib 'reek/smells/too_many_instance_variables'
 
 RSpec.describe Reek::Smells::TooManyInstanceVariables do
-  context 'reporting smell' do
-    it 'reports the smell parameters' do
-      src = <<-EOS
-        class Empty
-          def ivars
-            @a = @b = @c = @d = 1
-            @e = 1
-          end
+  let(:config) do
+    { Reek::Smells::TooManyInstanceVariables::MAX_ALLOWED_IVARS_KEY => 2 }
+  end
+
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        def bravo
+          @charlie = @delta = @echo = 1
         end
-      EOS
-
-      expect(src).to reek_of(described_class,
-                             lines: [1],
-                             count: 5,
-                             message: 'has at least 5 instance variables',
-                             context: 'Empty')
-    end
+      end
+    EOS
+
+    expect(src).to reek_of(:TooManyInstanceVariables,
+                           lines:   [1],
+                           context: 'Alfa',
+                           message: 'has at least 3 instance variables',
+                           source:  'string',
+                           count:   3).with_config(config)
   end
 
-  context 'counting instance variables' do
-    it 'should not report for non-excessive ivars' do
-      src = <<-EOS
-        class Empty
-          def ivars
-            @a = @b = @c = @d = 1
-          end
+  it 'should not report for non-excessive ivars' do
+    src = <<-EOS
+      class Alfa
+        def bravo
+          @charlie = @delta = 1
         end
-      EOS
-      expect(src).not_to reek_of(described_class)
-    end
-
-    it 'has a configurable maximum' do
-      src = <<-EOS
-        # :reek:TooManyInstanceVariables: { max_instance_variables: 5 }
-        class Empty
-          def ivars
-            @a = @b = @c = @d = 1
-            @e = 1
-          end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
+  end
+
+  it 'has a configurable maximum' do
+    src = <<-EOS
+      # :reek:TooManyInstanceVariables: { max_instance_variables: 3 }
+      class Alfa
+        def bravo
+          @charlie = @delta = @echo = 1
         end
-      EOS
-      expect(src).not_to reek_of(described_class)
-    end
-
-    it 'counts each ivar only once' do
-      src = <<-EOS
-        class Empty
-          def ivars
-            @a = @b = @c = @d = 1
-            @a = @b = @c = @d = 1
-          end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
+  end
+
+  it 'counts each ivar only once' do
+    src = <<-EOS
+      class Alfa
+        def bravo
+          @charlie = @delta = 1
+          @charlie = @delta = 1
         end
-      EOS
-      expect(src).not_to reek_of(described_class)
-    end
-
-    it 'should not report memoized ivars' do
-      src = <<-EOS
-        class Empty
-          def ivars
-            @a = @b = @c = @d = 1
-            @e ||= 1
-          end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
+  end
+
+  it 'does not report memoized bravo' do
+    src = <<-EOS
+      class Alfa
+        def bravo
+          @charlie = @delta = 1
+          @echo ||= 1
         end
-      EOS
-      expect(src).not_to reek_of(described_class)
-    end
-
-    it 'should not count ivars on inner classes altogether' do
-      src = <<-EOS
-        class Empty
-          class InnerA
-            def ivars
-              @a = @b = @c = @d = 1
-            end
-          end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
+  end
 
-          class InnerB
-            def ivars
-              @e = 1
-            end
+  it 'does not count ivars across inner classes' do
+    src = <<-EOS
+      class Alfa
+        class Bravo
+          def charlie
+            @delta = @echo = 1
           end
         end
-      EOS
-      expect(src).not_to reek_of(described_class)
-    end
-
-    it 'should not count ivars on modules altogether' do
-      src = <<-EOS
-        class Empty
-          class InnerA
-            def ivars
-              @a = @b = @c = @d = 1
-            end
-          end
 
-          module InnerB
-            def ivars
-              @e = 1
-            end
+        class Hotel
+          def india
+            @juliett = 1
           end
         end
-      EOS
-      expect(src).not_to reek_of(described_class)
-    end
-
-    it 'reports excessive ivars' do
-      src = <<-EOS
-        class Empty
-          def ivars
-            @a = @b = @c = @d = 1
-            @e = 1
+      end
+    EOS
+
+    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
+  end
+
+  it 'does not count ivars across inner modules and classes' do
+    src = <<-EOS
+      class Alfa
+        class Bravo
+          def charlie
+            @delta = @echo = 1
           end
         end
-      EOS
-      expect(src).to reek_of(described_class)
-    end
-
-    it 'reports excessive ivars even in different methods' do
-      src = <<-EOS
-        class Empty
-          def ivars_a
-            @a = @b = @c = @d = 1
-          end
 
-          def ivars_b
-            @e = 1
+        module Foxtrot
+          def golf
+            @hotel = 1
           end
         end
-      EOS
-      expect(src).to reek_of(described_class)
-    end
-
-    it 'should not report for ivars in 2 extensions' do
-      src = <<-EOS
-        class Full
-          def ivars_a
-            @a = @b = @c = @d = 1
-          end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
+  end
+
+  it 'reports excessive ivars across different methods' do
+    src = <<-EOS
+      class Alfa
+        def bravo
+          @charlie = @delta = 1
         end
 
-        class Full
-          def ivars_b
-            @a = @b = @c = @d = 1
-          end
+        def golf
+          @hotel = 1
         end
-      EOS
-      expect(src).not_to reek_of(described_class)
-    end
+      end
+    EOS
+
+    expect(src).to reek_of(:TooManyInstanceVariables).with_config(config)
   end
 end