reek 4.4.1 → 4.4.2

data/spec/reek/smells/too_many_instance_variables_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe Reek::Smells::TooManyInstanceVariables do
                            count:   3).with_config(config)
   end
 
-  it 'should not report for non-excessive ivars' do
+  it 'does not report for non-excessive ivars' do
     src = <<-EOS
       class Alfa
         def bravo

data/spec/reek/smells/too_many_methods_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe Reek::Smells::TooManyMethods do
                            count:   4).with_config(config)
   end
 
-  it 'should not report if we stay below max_methods' do
+  it 'does not report if we stay below max_methods' do
     src = <<-EOS
       class Alfa
         def bravo; end

data/spec/reek/smells/too_many_statements_spec.rb

@@ -42,12 +42,9 @@ RSpec.describe Reek::Smells::TooManyStatements do
       end
     EOS
 
-    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)
+    expect(src).
+      to reek_of(:TooManyStatements, lines: [2], context: 'Alfa#bravo').with_config(config).
+      and reek_of(:TooManyStatements, lines: [8], context: 'Alfa#foxtrot').with_config(config)
   end
 
   it 'does not report short methods' do

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -17,15 +17,18 @@ RSpec.describe Reek::Smells::UncommunicativeMethodName do
 
   describe 'default configuration' do
     it 'reports one-word names' do
-      expect('def a; end').to reek_of(:UncommunicativeMethodName)
+      src = 'def a; end'
+      expect(src).to reek_of(:UncommunicativeMethodName)
     end
 
     it 'reports names ending with a digit' do
-      expect('def xyz1; end').to reek_of(:UncommunicativeMethodName)
+      src = 'def xyz1; end'
+      expect(src).to reek_of(:UncommunicativeMethodName)
     end
 
     it 'reports camelcased names' do
-      expect('def aBBa; end').to reek_of(:UncommunicativeMethodName)
+      src = 'def aBBa; end'
+      expect(src).to reek_of(:UncommunicativeMethodName)
     end
 
     it 'does not report one-letter special characters' do
@@ -40,7 +43,7 @@ RSpec.describe Reek::Smells::UncommunicativeMethodName do
 
     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(:UncommunicativeMethodName).with_config('accept' => pattern)
+        expect(source).not_to reek_of(:UncommunicativeMethodName).with_config('accept' => pattern)
       end
     end
   end
@@ -56,7 +59,7 @@ RSpec.describe Reek::Smells::UncommunicativeMethodName do
   end
 
   describe '.default_config' do
-    it 'should merge in the default accept and reject patterns' do
+    it 'merges in the default accept and reject patterns' do
       expected = {
         'enabled' => true,
         'exclude' => [],
@@ -68,7 +71,7 @@ RSpec.describe Reek::Smells::UncommunicativeMethodName do
   end
 
   describe '.contexts' do
-    it 'should be scoped to classes and modules' do
+    it 'is scoped to classes and modules' do
       expect(described_class.contexts).to eq([:def, :defs])
     end
   end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -41,7 +41,7 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
 
     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)
+        expect(source).not_to reek_of(:UncommunicativeModuleName).with_config('accept' => pattern)
       end
     end
   end
@@ -57,7 +57,7 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
   end
 
   describe '.default_config' do
-    it 'should merge in the default accept and reject patterns' do
+    it 'merges in the default accept and reject patterns' do
       expected = {
         'enabled' => true,
         'exclude' => [],
@@ -69,7 +69,7 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
   end
 
   describe '.contexts' do
-    it 'are scoped to classes and modules' do
+    it 'indicates that this smell is 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

@@ -24,12 +24,9 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
       end
     EOS
 
-    expect(src).to reek_of(:UncommunicativeParameterName,
-                           lines: [1],
-                           name:  'x')
-    expect(src).to reek_of(:UncommunicativeParameterName,
-                           lines: [1],
-                           name:  'y')
+    expect(src).
+      to reek_of(:UncommunicativeParameterName, lines: [1], name: 'x').
+      and reek_of(:UncommunicativeParameterName, lines: [1], name: 'y')
   end
 
   { 'alfa.' => 'with a receiver',
@@ -93,7 +90,7 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
 
     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(:UncommunicativeParameterName).with_config('accept' => pattern)
+        expect(source).not_to reek_of(:UncommunicativeParameterName).with_config('accept' => pattern)
       end
     end
   end
@@ -109,7 +106,7 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
   end
 
   describe '.default_config' do
-    it 'should merge in the default accept and reject patterns' do
+    it 'merges in the default accept and reject patterns' do
       expected = {
         'enabled' => true,
         'exclude' => [],
@@ -122,7 +119,7 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
   end
 
   describe '.contexts' do
-    it 'are scoped to classes and modules' do
+    it 'indicates that this smell is scoped to method definitions' do
       expect(described_class.contexts).to eq([:def, :defs])
     end
   end

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -25,12 +25,8 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
       end
     EOS
 
-    expect(src).to reek_of(:UncommunicativeVariableName,
-                           lines: [2],
-                           name:  'x')
-    expect(src).to reek_of(:UncommunicativeVariableName,
-                           lines: [3],
-                           name:  'y')
+    expect(src).to reek_of(:UncommunicativeVariableName, lines: [2], name:  'x').
+      and reek_of(:UncommunicativeVariableName, lines: [3], name:  'y')
   end
 
   context 'instance variables' do
@@ -90,8 +86,8 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
         end
       EOS
 
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x').
+        and reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports block parameters used outside of methods' do
@@ -121,8 +117,8 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
         end
       EOS
 
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x').
+        and reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports splatted nested block parameters' do
@@ -132,8 +128,8 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
         end
       EOS
 
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x').
+        and reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports deeply nested block parameters' do
@@ -143,9 +139,9 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
         end
       EOS
 
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'z')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x').
+        and reek_of(:UncommunicativeVariableName, name: 'y').
+        and reek_of(:UncommunicativeVariableName, name: 'z')
     end
 
     it 'reports shadowed block parameters' do
@@ -155,19 +151,19 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
         end
       EOS
 
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x').
+        and reek_of(:UncommunicativeVariableName, name: 'y')
     end
   end
 
   describe '`accept` patterns' do
     let(:src) { 'def alfa; bravo2 = 42; end' }
 
+    # FIXME: Move the loop out of the it?
     it 'make smelly names pass via regex / strings given by list / literal' do
-      expect(src).to reek_of(:UncommunicativeVariableName)
-
       [[/bravo2/], /bravo2/, ['bravo2'], 'bravo2'].each do |pattern|
-        expect(src).to_not reek_of(:UncommunicativeVariableName).with_config('accept' => pattern)
+        expect(src).to reek_of(:UncommunicativeVariableName).
+          and not_reek_of(:UncommunicativeVariableName).with_config('accept' => pattern)
       end
     end
   end
@@ -175,17 +171,17 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
   describe '`reject` patterns' do
     let(:src) { 'def alfa; foobar = 42; end' }
 
+    # FIXME: Move the loop out of the it?
     it 'reject smelly names via regex / strings given by list / literal' do
-      expect(src).not_to reek_of(:UncommunicativeVariableName)
-
       [[/foobar/], /foobar/, ['foobar'], 'foobar'].each do |pattern|
-        expect(src).to reek_of(:UncommunicativeVariableName).with_config('reject' => pattern)
+        expect(src).to not_reek_of(:UncommunicativeVariableName).
+          and reek_of(:UncommunicativeVariableName).with_config('reject' => pattern)
       end
     end
   end
 
   describe '.default_config' do
-    it 'should merge in the default accept and reject patterns' do
+    it 'merges in the default accept and reject patterns' do
       expected = {
         'enabled' => true,
         'exclude' => [],

data/spec/reek/smells/unused_parameters_spec.rb

@@ -22,82 +22,93 @@ RSpec.describe Reek::Smells::UnusedParameters do
       end
     EOS
 
-    expect(src).to reek_of(:UnusedParameters,
-                           lines: [1],
-                           name:  'bravo')
-    expect(src).to reek_of(:UnusedParameters,
-                           lines: [1],
-                           name:  'charlie')
+    expect(src).
+      to reek_of(:UnusedParameters, lines: [1], name: 'bravo').
+      and reek_of(:UnusedParameters, lines: [1], name:  'charlie')
   end
 
   it 'reports nothing for no parameters' do
-    expect('def alfa; end').not_to reek_of(:UnusedParameters)
+    src = 'def alfa; end'
+    expect(src).not_to reek_of(:UnusedParameters)
   end
 
   it 'reports nothing for used parameter' do
-    expect('def alfa(bravo); bravo; end').not_to reek_of(:UnusedParameters)
+    src = 'def alfa(bravo); bravo; end'
+    expect(src).not_to reek_of(:UnusedParameters)
   end
 
   it 'reports for 1 used and 2 unused parameter' do
     src = 'def alfa(bravo, charlie, delta); bravo end'
 
-    expect(src).not_to reek_of(:UnusedParameters, name: 'bravo')
-    expect(src).to reek_of(:UnusedParameters, name: 'charlie')
-    expect(src).to reek_of(:UnusedParameters, name: 'delta')
+    expect(src).
+      to not_reek_of(:UnusedParameters, name: 'bravo').
+      and reek_of(:UnusedParameters, name: 'charlie').
+      and reek_of(:UnusedParameters, name: 'delta')
   end
 
   it 'reports nothing for named parameters prefixed with _' do
-    expect('def alfa(_bravo); end').not_to reek_of(:UnusedParameters)
+    src = 'def alfa(_bravo); end'
+    expect(src).not_to reek_of(:UnusedParameters)
   end
 
   it 'reports nothing when using a parameter via self assignment' do
-    expect('def alfa(bravo); bravo += 1; end').not_to reek_of(:UnusedParameters)
+    src = 'def alfa(bravo); bravo += 1; end'
+    expect(src).not_to reek_of(:UnusedParameters)
   end
 
   it 'reports nothing when using a parameter on a rescue' do
-    expect('def alfa(bravo = 3); puts "nothing"; rescue; retry if bravo -= 1 > 0; raise; end').
-      not_to reek_of(:UnusedParameters)
+    src = 'def alfa(bravo = 3); puts "nothing"; rescue; retry if bravo -= 1 > 0; raise; end'
+    expect(src).not_to reek_of(:UnusedParameters)
   end
 
   context 'using super' do
     it 'reports nothing with implicit arguments' do
-      expect('def alfa(*bravo); super; end').not_to reek_of(:UnusedParameters)
+      src = 'def alfa(*bravo); super; end'
+      expect(src).not_to reek_of(:UnusedParameters)
     end
 
     it 'reports something when explicitely passing no arguments' do
-      expect('def alfa(*bravo); super(); end').to reek_of(:UnusedParameters)
+      src = 'def alfa(*bravo); super(); end'
+      expect(src).to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing when explicitely passing all arguments' do
-      expect('def alfa(*bravo); super(*bravo); end').not_to reek_of(:UnusedParameters)
+      src = 'def alfa(*bravo); super(*bravo); end'
+      expect(src).not_to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing in a nested context' do
-      expect('def alfa(*bravo); charlie(super); end').not_to reek_of(:UnusedParameters)
+      src = 'def alfa(*bravo); charlie(super); end'
+      expect(src).not_to reek_of(:UnusedParameters)
     end
   end
 
   context 'anonymous parameters' do
     it 'reports nothing for unused anonymous parameter' do
-      expect('def alfa(_); end').not_to reek_of(:UnusedParameters)
+      src = 'def alfa(_); end'
+      expect(src).not_to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing for unused anonymous splatted parameter' do
-      expect('def alfa(*); end').not_to reek_of(:UnusedParameters)
+      src = 'def alfa(*); end'
+      expect(src).not_to reek_of(:UnusedParameters)
     end
   end
 
   context 'splatted parameters' do
     it 'reports nothing for used splatted parameter' do
-      expect('def alfa(*bravo); bravo; end').not_to reek_of(:UnusedParameters)
+      src = 'def alfa(*bravo); bravo; end'
+      expect(src).not_to reek_of(:UnusedParameters)
     end
 
     it 'reports something when not using a keyword argument with splat' do
-      expect('def alfa(**bravo); end').to reek_of(:UnusedParameters)
+      src = 'def alfa(**bravo); end'
+      expect(src).to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing when using a keyword argument with splat' do
-      expect('def alfa(**bravo); bravo; end').not_to reek_of(:UnusedParameters)
+      src = 'def alfa(**bravo); bravo; end'
+      expect(src).not_to reek_of(:UnusedParameters)
     end
   end
 end

data/spec/reek/smells/unused_private_method_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
                            context: 'Alfa',
                            message: "has the unused private instance method 'charlie'",
                            source:  'string',
-                           name:    :charlie)
+                           name:    'charlie')
   end
 
   it 'does count all occurences' do
@@ -33,12 +33,9 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
       end
     EOS
 
-    expect(src).to reek_of(:UnusedPrivateMethod,
-                           lines: [4],
-                           name:  :charlie)
-    expect(src).to reek_of(:UnusedPrivateMethod,
-                           lines: [7],
-                           name:  :charlie)
+    expect(src).
+      to reek_of(:UnusedPrivateMethod, lines: [4], name: 'charlie').
+      and reek_of(:UnusedPrivateMethod, lines: [7], name: 'charlie')
   end
 
   context 'unused private methods' do
@@ -51,8 +48,9 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :bravo)
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :charlie)
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, name: 'bravo').
+        and reek_of(:UnusedPrivateMethod, name: 'charlie')
     end
 
     it 'reports instance methods in the correct class' do
@@ -65,12 +63,9 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod,
-                                context: 'Alfa::Bravo',
-                                name: :charlie)
-      expect(source).not_to reek_of(:UnusedPrivateMethod,
-                                    context: 'Alfa',
-                                    name: :charlie)
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, context: 'Alfa::Bravo', name: 'charlie').
+        and not_reek_of(:UnusedPrivateMethod, context: 'Alfa', name: 'charlie')
     end
 
     it 'discounts calls to identically named methods in nested classes' do
@@ -90,12 +85,9 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
         end
       EOF
 
-      expect(source).not_to reek_of(:UnusedPrivateMethod,
-                                    context: 'Alfa::Bravo',
-                                    name: :charlie)
-      expect(source).to reek_of(:UnusedPrivateMethod,
-                                context: 'Alfa',
-                                name: :charlie)
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, context: 'Alfa', name: 'charlie').
+        and not_reek_of(:UnusedPrivateMethod, context: 'Alfo::Bravo', name: 'charlie')
     end
 
     it 'creates warnings correctly' do
@@ -107,12 +99,9 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod,
-                                name: :bravo,
-                                lines: [3])
-      expect(source).to reek_of(:UnusedPrivateMethod,
-                                name: :charlie,
-                                lines: [4])
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, name: 'bravo', lines: [3]).
+        and reek_of(:UnusedPrivateMethod, name: 'charlie', lines: [4])
     end
   end
 
@@ -127,8 +116,9 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :charlie)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :bravo)
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, name: 'charlie').
+        and not_reek_of(:UnusedPrivateMethod, name: 'bravo')
     end
   end
 
@@ -188,15 +178,17 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
     it 'excludes them via direct match in the app configuration' do
       config = { Reek::Smells::SmellDetector::EXCLUDE_KEY => ['Alfa#charlie'] }
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :bravo).with_config(config)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :charlie).with_config(config)
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, name: 'bravo').with_config(config).
+        and not_reek_of(:UnusedPrivateMethod, name: 'charlie').with_config(config)
     end
 
     it 'excludes them via regex in the app configuration' do
       config = { Reek::Smells::SmellDetector::EXCLUDE_KEY => [/charlie/] }
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :bravo).with_config(config)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :charlie).with_config(config)
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, name: 'bravo').with_config(config).
+        and not_reek_of(:UnusedPrivateMethod, name: 'charlie').with_config(config)
     end
   end
 end