reek 4.4.0 → 4.4.1

data/spec/reek/smells/too_many_methods_spec.rb

@@ -1,78 +1,54 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/too_many_methods'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::TooManyMethods do
-  let(:detector) { described_class.new('max_methods' => 2) }
-  let(:source_name) { 'string' }
-
-  it_should_behave_like 'SmellDetector'
+  let(:config) do
+    { Reek::Smells::TooManyMethods::MAX_ALLOWED_METHODS_KEY => 3 }
+  end
 
-  context 'counting methods' do
-    it 'should not report if we stay below max_methods' do
-      src = <<-EOS
-        class Dummy
-          def m1; end
-          def m2; end
-        end
-      EOS
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::ModuleContext.new(nil, syntax_tree)
-      expect(detector.sniff(ctx)).to be_empty
-    end
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        def bravo; end
+        def charlie; end
+        def delta; end
+        def echo; end
+      end
+    EOS
 
-    it 'should report if we exceed max_methods' do
-      src = <<-EOS
-        class Dummy
-          def m1; end
-          def m2; end
-          def m3; end
-        end
-      EOS
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::ModuleContext.new(nil, syntax_tree)
-      smells = detector.sniff(ctx)
-      expect(smells.length).to eq(1)
-      expect(smells[0].smell_type).to eq(described_class.smell_type)
-      expect(smells[0].parameters[:count]).to eq(3)
-    end
+    expect(src).to reek_of(:TooManyMethods,
+                           lines:   [1],
+                           context: 'Alfa',
+                           message: 'has at least 4 methods',
+                           source:  'string',
+                           count:   4).with_config(config)
   end
 
-  context 'with a nested module' do
-    it 'stops at a nested module' do
-      src = <<-EOS
-        class Dummy
-          def m1; end
-          def m2; end
-          module Hidden
-            def m3; end
-            def m4; end
-            def m5; end
-            def m6; end
-          end
-        end
-      EOS
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::ModuleContext.new(nil, syntax_tree)
-      expect(detector.sniff(ctx)).to be_empty
-    end
+  it 'should not report if we stay below max_methods' do
+    src = <<-EOS
+      class Alfa
+        def bravo; end
+        def charlie; end
+        def delta; end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:TooManyMethods).with_config(config)
   end
 
-  it 'reports correctly when the class has many methods' do
+  it 'stops at a nested module' do
     src = <<-EOS
-      class Dummy
-        def m1; end
-        def m2; end
-        def m3; end
+      class Alfa
+        def bravo; end
+        def charlie; end
+
+        module Hidden
+          def delta; end
+          def echo; end
+        end
       end
     EOS
 
-    syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-    ctx = Reek::Context::ModuleContext.new(nil, syntax_tree)
-    warning = detector.sniff(ctx)[0]
-    expect(warning.source).to eq(source_name)
-    expect(warning.smell_type).to eq(described_class.smell_type)
-    expect(warning.parameters[:count]).to eq(3)
-    expect(warning.lines).to eq([1])
+    expect(src).not_to reek_of(:TooManyMethods).with_config(config)
   end
 end

data/spec/reek/smells/too_many_statements_spec.rb

@@ -1,69 +1,93 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/too_many_statements'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::TooManyStatements do
-  it 'should not report short methods' do
-    src = 'def short(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;end'
-    expect(src).not_to reek_of(:TooManyStatements)
+  let(:config) do
+    { Reek::Smells::TooManyStatements::MAX_ALLOWED_STATEMENTS_KEY => 2 }
   end
 
-  it 'should report long methods' do
-    src = 'def long() alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'
-    expect(src).to reek_of(:TooManyStatements)
-  end
-
-  it 'should not report initialize' do
+  it 'reports the right values' do
     src = <<-EOS
-      def initialize(arga)
-        alf = f(1); @bet = 2; @cut = 3; @dit = 4; @emp = 5; @fry = 6
+      class Alfa
+        def bravo
+          charlie = 1
+          delta   = 2
+          echo    = 3
+        end
       end
     EOS
-    expect(src).not_to reek_of(:TooManyStatements)
+
+    expect(src).to reek_of(:TooManyStatements,
+                           lines:   [2],
+                           context: 'Alfa#bravo',
+                           message: 'has approx 3 statements',
+                           source:  'string',
+                           count:   3).with_config(config)
   end
 
-  it 'should report long inner block' do
+  it 'does count all occurences' do
     src = <<-EOS
-      def long()
-        f(3)
-        self.each do |xyzero|
-          xyzero = 1
-          xyzero = 2
-          xyzero = 3
-          xyzero = 4
-          xyzero = 5
-          xyzero = 6
+      class Alfa
+        def bravo
+          charlie = 1
+          delta   = 2
+          echo    = 3
+        end
+
+        def foxtrot
+          golf  = 1
+          hotel = 2
+          india = 3
         end
       end
     EOS
-    expect(src).to reek_of(:TooManyStatements)
+
+    expect(src).to reek_of(:TooManyStatements,
+                           lines:   [2],
+                           context: 'Alfa#bravo').with_config(config)
+    expect(src).to reek_of(:TooManyStatements,
+                           lines:   [8],
+                           context: 'Alfa#foxtrot').with_config(config)
   end
-end
 
-RSpec.describe Reek::Smells::TooManyStatements do
-  let(:detector) { build(:smell_detector, smell_type: :TooManyStatements) }
+  it 'does not report short methods' do
+    src = <<-EOS
+      class Alfa
+        def bravo
+          charlie = 1
+          delta   = 2
+        end
+      end
+    EOS
 
-  it_should_behave_like 'SmellDetector'
+    expect(src).not_to reek_of(:TooManyStatements).with_config(config)
+  end
 
-  context 'when the method has 30 statements' do
-    let(:number_of_statements) { 30 }
-    let(:smells) do
-      ctx = double('method_context').as_null_object
-      expect(ctx).to receive(:number_of_statements).and_return(number_of_statements)
-      expect(ctx).to receive(:config_for).with(described_class).and_return({})
-      detector.sniff(ctx)
-    end
+  it 'does not report initialize' do
+    src = <<-EOS
+      class Alfa
+        def initialize
+          charlie = 1
+          delta   = 2
+          echo    = 3
+        end
+      end
+    EOS
 
-    it 'reports only 1 smell' do
-      expect(smells.length).to eq(1)
-    end
+    expect(src).not_to reek_of(:TooManyStatements).with_config(config)
+  end
 
-    it 'reports the number of statements' do
-      expect(smells[0].parameters[:count]).to eq(number_of_statements)
-    end
+  it 'reports long inner block' do
+    src = <<-EOS
+      def long
+        self.each do |x|
+          charlie = 1
+          delta   = 2
+          echo    = 3
+        end
+      end
+    EOS
 
-    it 'reports the correct smell sub class' do
-      expect(smells[0].smell_type).to eq(described_class.smell_type)
-    end
+    expect(src).to reek_of(:TooManyStatements).with_config(config)
   end
 end

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -1,10 +1,19 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/uncommunicative_method_name'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UncommunicativeMethodName do
-  let(:detector) { build(:smell_detector, smell_type: :UncommunicativeMethodName) }
-  it_should_behave_like 'SmellDetector'
+  it 'reports the right values' do
+    src = <<-EOS
+      def m; end
+    EOS
+
+    expect(src).to reek_of(:UncommunicativeMethodName,
+                           lines:   [1],
+                           context: 'm',
+                           message: "has the name 'm'",
+                           source:  'string',
+                           name:    'm')
+  end
 
   describe 'default configuration' do
     it 'reports one-word names' do
@@ -26,44 +35,22 @@ RSpec.describe Reek::Smells::UncommunicativeMethodName do
     end
   end
 
-  describe 'sniff' do
-    let(:source) { 'def x; end' }
-    let(:context) { code_context(source) }
-    let(:detector) { build(:smell_detector, smell_type: :UncommunicativeMethodName) }
-
-    it 'returns an array of smell warnings' do
-      smells = detector.sniff(context)
-      expect(smells.length).to eq(1)
-      expect(smells[0]).to be_a_kind_of(Reek::Smells::SmellWarning)
-    end
-
-    it 'contains proper smell warnings' do
-      smells = detector.sniff(context)
-      warning = smells[0]
-
-      expect(warning.smell_type).to eq(Reek::Smells::UncommunicativeMethodName.smell_type)
-      expect(warning.parameters[:name]).to eq('x')
-      expect(warning.context).to match(/#{warning.parameters[:name]}/)
-      expect(warning.lines).to eq([1])
-    end
-  end
-
   describe '`accept` patterns' do
     let(:source) { 'def x; end' }
 
     it 'make smelly names pass via regex / strings given by list / literal' do
       [[/x/], /x/, ['x'], 'x'].each do |pattern|
-        expect(source).to_not reek_of(described_class).with_config('accept' => pattern)
+        expect(source).to_not reek_of(:UncommunicativeMethodName).with_config('accept' => pattern)
       end
     end
   end
 
   describe '`reject` patterns' do
-    let(:source) { 'def helper; end' }
+    let(:source) { 'def alfa; end' }
 
     it 'reject smelly names via regex / strings given by list / literal' do
-      [[/helper/], /helper/, ['helper'], 'helper'].each do |pattern|
-        expect(source).to reek_of(described_class).with_config('reject' => pattern)
+      [[/alfa/], /alfa/, ['alfa'], 'alfa'].each do |pattern|
+        expect(source).to reek_of(:UncommunicativeMethodName).with_config('reject' => pattern)
       end
     end
   end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -1,16 +1,25 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/uncommunicative_module_name'
-require_relative 'smell_detector_shared'
-require_lib 'reek/context/code_context'
 
 RSpec.describe Reek::Smells::UncommunicativeModuleName do
-  let(:detector) { build(:smell_detector, smell_type: :UncommunicativeModuleName) }
-  it_should_behave_like 'SmellDetector'
+  it 'reports the right values' do
+    src = <<-EOS
+      class K
+      end
+    EOS
+
+    expect(src).to reek_of(:UncommunicativeModuleName,
+                           lines:   [1],
+                           context: 'K',
+                           message: "has the name 'K'",
+                           source:  'string',
+                           name:    'K')
+  end
 
   describe 'default configuration' do
     ['class', 'module'].each do |type|
       it 'does not report one-word name' do
-        expect("#{type} Helper; end").not_to reek_of(:UncommunicativeModuleName)
+        expect("#{type} Alfa; end").not_to reek_of(:UncommunicativeModuleName)
       end
 
       it 'reports one-letter name' do
@@ -22,49 +31,27 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
       end
 
       it 'reports long name ending in a number' do
-        expect("#{type} Printer2; end").to reek_of(:UncommunicativeModuleName, name: 'Printer2')
+        expect("#{type} Alfa2; end").to reek_of(:UncommunicativeModuleName, name: 'Alfa2')
       end
     end
   end
 
-  describe 'sniff' do
-    let(:source) { 'class Foo::X; end' }
-    let(:context) { code_context(source) }
-    let(:detector) { build(:smell_detector, smell_type: :UncommunicativeModuleName) }
-
-    it 'returns an array of smell warnings' do
-      smells = detector.sniff(context)
-      expect(smells.length).to eq(1)
-      expect(smells[0]).to be_a_kind_of(Reek::Smells::SmellWarning)
-    end
-
-    it 'contains proper smell warnings' do
-      smells = detector.sniff(context)
-      warning = smells[0]
-
-      expect(warning.smell_type).to eq(Reek::Smells::UncommunicativeModuleName.smell_type)
-      expect(warning.parameters[:name]).to eq('X')
-      expect(warning.context).to match(/#{warning.parameters[:name]}/)
-      expect(warning.lines).to eq([1])
-    end
-  end
-
   describe '`accept` patterns' do
-    let(:source) { 'class Classy1; end' }
+    let(:source) { 'class Alfa1; end' }
 
-    it 'make smelly names pass via regex / strings given by list / literal' do
-      [[/lassy/], /lassy/, ['lassy'], 'lassy'].each do |pattern|
-        expect(source).to_not reek_of(described_class).with_config('accept' => pattern)
+    it 'makes smelly names pass via regex / strings given by list / literal' do
+      [[/lfa/], /lfa/, ['lfa'], 'lfa'].each do |pattern|
+        expect(source).to_not reek_of(:UncommunicativeModuleName).with_config('accept' => pattern)
       end
     end
   end
 
   describe '`reject` patterns' do
-    let(:source) { 'class BaseHelper; end' }
+    let(:source) { 'class Alfa; end' }
 
-    it 'reject smelly names via regex / strings given by list / literal' do
-      [[/Helper/], /Helper/, ['Helper'], 'Helper'].each do |pattern|
-        expect(source).to reek_of(described_class).with_config('reject' => pattern)
+    it 'rejects smelly names via regex / strings given by list / literal' do
+      [[/Alfa/], /Alfa/, ['Alfa'], 'Alfa'].each do |pattern|
+        expect(source).to reek_of(:UncommunicativeModuleName).with_config('reject' => pattern)
       end
     end
   end
@@ -82,7 +69,7 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
   end
 
   describe '.contexts' do
-    it 'should be scoped to classes and modules' do
+    it 'are scoped to classes and modules' do
       expect(described_class.contexts).to eq([:module, :class])
     end
   end

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -1,115 +1,109 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/uncommunicative_parameter_name'
-require_relative 'smell_detector_shared'
-require_lib 'reek/context/method_context'
 
 RSpec.describe Reek::Smells::UncommunicativeParameterName do
-  let(:detector) { build(:smell_detector, smell_type: :UncommunicativeParameterName) }
-  it_should_behave_like 'SmellDetector'
+  it 'reports the right values' do
+    src = <<-EOS
+      def alfa(x)
+        x
+      end
+    EOS
+
+    expect(src).to reek_of(:UncommunicativeParameterName,
+                           lines:   [1],
+                           context: 'alfa',
+                           message: "has the parameter name 'x'",
+                           source:  'string',
+                           name:    'x')
+  end
+
+  it 'does count all occurences' do
+    src = <<-EOS
+      def alfa(x, y)
+        [x, y]
+      end
+    EOS
+
+    expect(src).to reek_of(:UncommunicativeParameterName,
+                           lines: [1],
+                           name:  'x')
+    expect(src).to reek_of(:UncommunicativeParameterName,
+                           lines: [1],
+                           name:  'y')
+  end
 
-  { 'obj.' => 'with a receiver',
+  { 'alfa.' => 'with a receiver',
     '' => 'without a receiver' }.each do |host, description|
     context "in a method definition #{description}" do
       it 'does not recognise *' do
-        expect("def #{host}help(xray, *) basics(17) end").
-          not_to reek_of(:UncommunicativeParameterName)
-      end
-
-      it "reports parameter's name" do
-        src = "def #{host}help(x) basics(x) end"
-        expect(src).to reek_of(:UncommunicativeParameterName,
-                               name: 'x')
+        expect("def #{host}bravo(*); end").not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'does not report unused parameters' do
-        src = "def #{host}help(x) basics(17) end"
+        src = "def #{host}bravo(x); charlie; end"
         expect(src).not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'does not report two-letter parameter names' do
-        expect("def #{host}help(ab) basics(ab) end").
-          not_to reek_of(:UncommunicativeParameterName)
+        src = "def #{host}bravo(ab); charlie(ab); end"
+        expect(src).not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports names of the form "x2"' do
-        src = "def #{host}help(x2) basics(x2) end"
-        expect(src).to reek_of(:UncommunicativeParameterName,
-                               name: 'x2')
+        src = "def #{host}bravo(x2) charlie(x2) end"
+        expect(src).to reek_of(:UncommunicativeParameterName, name: 'x2')
       end
 
       it 'reports long name ending in a number' do
-        src = "def #{host}help(param2) basics(param2) end"
-        expect(src).to reek_of(:UncommunicativeParameterName,
-                               name: 'param2')
+        src = "def #{host}bravo(param2) charlie(param2) end"
+        expect(src).to reek_of(:UncommunicativeParameterName, name: 'param2')
       end
 
       it 'does not report unused anonymous parameter' do
-        expect("def #{host}help(_) basics(17) end").
-          not_to reek_of(:UncommunicativeParameterName)
+        src = "def #{host}bravo(_); charlie; end"
+        expect(src).not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports used anonymous parameter' do
-        expect("def #{host}help(_) basics(_) end").
-          to reek_of(:UncommunicativeParameterName)
+        src = "def #{host}bravo(_); charlie(_) end"
+        expect(src).to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports used parameters marked as unused' do
-        expect("def #{host}help(_unused) basics(_unused) end").
-          to reek_of(:UncommunicativeParameterName)
+        src = "def #{host}bravo(_unused) charlie(_unused) end"
+        expect(src).to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports names inside array decomposition' do
-        src = "def #{host}help((b, nice)) basics(b, nice) end"
+        src = "def #{host}bravo((x, charlie)) delta(x, charlie) end"
         expect(src).to reek_of(:UncommunicativeParameterName,
-                               name: 'b')
+                               name: 'x')
       end
 
       it 'reports names inside nested array decomposition' do
-        src = "def #{host}help((foo, (bar, c))) basics(foo, c) end"
+        src = "def #{host}bravo((charlie, (delta, x))) echo(charlie, x) end"
         expect(src).to reek_of(:UncommunicativeParameterName,
-                               name: 'c')
+                               name: 'x')
       end
     end
   end
 
-  describe 'sniff' do
-    let(:source) { 'def foo(bar2); baz(bar2); end' }
-    let(:context) { method_context(source) }
-    let(:detector) { build(:smell_detector, smell_type: :UncommunicativeParameterName) }
-
-    it 'returns an array of smell warnings' do
-      smells = detector.sniff(context)
-      expect(smells.length).to eq(1)
-      expect(smells[0]).to be_a_kind_of(Reek::Smells::SmellWarning)
-    end
-
-    it 'contains proper smell warnings' do
-      smells = detector.sniff(context)
-      warning = smells[0]
-
-      expect(warning.smell_type).to eq(Reek::Smells::UncommunicativeParameterName.smell_type)
-      expect(warning.parameters[:name]).to eq('bar2')
-      expect(warning.context).to match('foo')
-      expect(warning.lines).to eq([1])
-    end
-  end
-
   describe '`accept` patterns' do
-    let(:source) { 'def foo(bar2); baz(bar2); end' }
+    let(:source) { 'def alfa(bar2); charlie(bar2); end' }
 
     it 'make smelly names pass via regex / strings given by list / literal' do
       [[/bar2/], /bar2/, ['bar2'], 'bar2'].each do |pattern|
-        expect(source).to_not reek_of(described_class).with_config('accept' => pattern)
+        expect(source).to_not reek_of(:UncommunicativeParameterName).with_config('accept' => pattern)
       end
     end
   end
 
   describe '`reject` patterns' do
-    let(:source) { 'def foo(bar); baz(bar); end' }
+    let(:source) { 'def alfa(bravo); charlie(bravo); end' }
 
     it 'reject smelly names via regex / strings given by list / literal' do
-      [[/bar/], /bar/, ['bar'], 'bar'].each do |pattern|
-        expect(source).to reek_of(described_class).with_config('reject' => pattern)
+      [[/bravo/], /bravo/, ['bravo'], 'bravo'].each do |pattern|
+        expect(source).to reek_of(:UncommunicativeParameterName).with_config('reject' => pattern)
       end
     end
   end
@@ -122,12 +116,13 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
         'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/, /^_/],
         'accept'  => []
       }
+
       expect(described_class.default_config).to eq(expected)
     end
   end
 
   describe '.contexts' do
-    it 'should be scoped to classes and modules' do
+    it 'are scoped to classes and modules' do
       expect(described_class.contexts).to eq([:def, :defs])
     end
   end