reek 4.4.0 → 4.4.1

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -1,140 +1,148 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/uncommunicative_variable_name'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UncommunicativeVariableName do
-  let(:detector) do
-    build(:smell_detector, smell_type: :UncommunicativeVariableName)
+  it 'reports the right values' do
+    src = <<-EOS
+      def alfa
+        x = 5
+      end
+    EOS
+
+    expect(src).to reek_of(:UncommunicativeVariableName,
+                           lines:   [2],
+                           context: 'alfa',
+                           message: "has the variable name 'x'",
+                           source:  'string',
+                           name:    'x')
   end
 
-  it_should_behave_like 'SmellDetector'
+  it 'does count all occurences' do
+    src = <<-EOS
+      def alfa
+        x = 3
+        y = 7
+      end
+    EOS
+
+    expect(src).to reek_of(:UncommunicativeVariableName,
+                           lines: [2],
+                           name:  'x')
+    expect(src).to reek_of(:UncommunicativeVariableName,
+                           lines: [3],
+                           name:  'y')
+  end
 
-  context 'field name' do
-    it 'does not report use of one-letter fieldname' do
-      src = 'class Thing; def simple(fred) @x end end'
+  context 'instance variables' do
+    it 'does not report use of one-letter names' do
+      src = 'class Alfa; def bravo; @x; end; end'
       expect(src).not_to reek_of(:UncommunicativeVariableName)
     end
-    it 'reports one-letter fieldname in assignment' do
-      src = 'class Thing; def simple(fred) @x = fred end end'
+
+    it 'reports one-letter names in assignment' do
+      src = 'class Alfa; def bravo(charlie) @x = charlie; end; end'
       expect(src).to reek_of(:UncommunicativeVariableName, name: '@x')
     end
   end
 
-  context 'local variable name' do
-    it 'does not report one-word variable name' do
-      expect('def help(fred) simple = jim(45) end').
-        not_to reek_of(:UncommunicativeVariableName)
-    end
-
+  context 'local variables' do
     it 'does not report single underscore as a variable name' do
-      expect('def help(fred) _ = jim(45) end').not_to reek_of(:UncommunicativeVariableName)
+      src = 'def alfa; _ = bravo(); end'
+      expect(src).not_to reek_of(:UncommunicativeVariableName)
     end
 
-    it 'reports one-letter variable name' do
-      src = 'def simple(fred) x = jim(45) end'
+    it 'reports one-letter names' do
+      src = 'def alfa; x = bravo(); end'
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
     end
 
-    it 'reports name of the form "x2"' do
-      src = 'def simple(fred) x2 = jim(45) end'
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x2')
+    it 'reports names ending with a digit' do
+      src = 'def alfa; var123 = bravo(); end'
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'var123')
     end
 
-    it 'reports long name ending in a number' do
-      bad_var = 'var123'
-      src = "def simple(fred) #{bad_var} = jim(45) end"
-      expect(src).to reek_of(:UncommunicativeVariableName,
-                             name: bad_var)
-    end
-
-    it 'reports variable name only once' do
-      src = 'def simple(fred) x = jim(45); x = y end'
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::CodeContext.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[:name]).to eq('x')
-      expect(smells[0].lines).to eq([1, 1])
+    it 'reports camelcased names' do
+      src = 'def alfa; bravoCharlie = delta(); end'
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'bravoCharlie')
     end
 
     it 'reports a bad name inside a block' do
-      src = 'def clean(text) text.each { q2 = 3 } end'
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'q2')
+      src = 'def alfa; bravo.each { x = 42 }; end'
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
     end
 
     it 'reports variable name outside any method' do
-      expect('class Simple; x = jim(45); end').to reek_of(:UncommunicativeVariableName,
-                                                          name: 'x')
+      src = 'class Alfa; x = bravo(); end'
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
     end
-  end
 
-  context 'block parameter name' do
-    it 'reports deep block parameter' do
-      src = <<-EOS
-        def bad
-          unless @mod then
-            @sig.each { |x| x.to_s }
-          end
-        end
-      EOS
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
+    it "reports bad names starting with '_'" do
+      src = 'def alfa; _bravoCharlie_42 = delta(); end'
+      expect(src).to reek_of(:UncommunicativeVariableName, name: '_bravoCharlie_42')
     end
+  end
 
+  context 'block parameters' do
     it 'reports all relevant block parameters' do
       src = <<-EOS
-        def bad
-          @foo.map { |x, y| x + y }
+        def alfa
+          @bravo.map { |x, y| x + y }
         end
       EOS
+
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports block parameters used outside of methods' do
       src = <<-EOS
-      class Foo
-        @foo.map { |x| x * 2 }
-      end
+        class Alfa
+          @bravo.map { |x| x * 2 }
+        end
       EOS
+
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
     end
 
     it 'reports splatted block parameters correctly' do
       src = <<-EOS
-        def bad
-          @foo.map { |*y| y << 1 }
+        def alfa
+          @bravo.map { |*y| y << 1 }
         end
       EOS
+
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports nested block parameters' do
       src = <<-EOS
-        def bad
-          @foo.map { |(x, y)| x + y }
+        def alfa
+          @bravo.map { |(x, y)| x + y }
         end
       EOS
+
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports splatted nested block parameters' do
       src = <<-EOS
-        def bad
-          @foo.map { |(x, *y)| x + y }
+        def def alfa
+          @bravo.map { |(x, *y)| x + y }
         end
       EOS
+
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports deeply nested block parameters' do
       src = <<-EOS
-        def bad
-          @foo.map { |(x, (y, z))| x + y + z }
+        def alfa
+          @bravo.map { |(x, (y, z))| x + y + z }
         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')
@@ -142,51 +150,56 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
 
     it 'reports shadowed block parameters' do
       src = <<-EOS
-        def bad
-          @foo.map { |x; y| y = x * 2 }
+        def alfa
+          @bravo.map { |x; y| y = x * 2 }
         end
       EOS
+
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
       expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
   end
 
-  context 'when a smell is reported' do
-    let(:warning) do
-      src = <<-EOS
-        def bad
-          unless @mod then
-             x2 = xy.to_s
-             x2
-             x2 = 56
-          end
-        end
-      EOS
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::CodeContext.new(nil, syntax_tree)
-      detector.sniff(ctx).first
-    end
+  describe '`accept` patterns' do
+    let(:src) { 'def alfa; bravo2 = 42; end' }
 
-    it_should_behave_like 'common fields set correctly'
+    it 'make smelly names pass via regex / strings given by list / literal' do
+      expect(src).to reek_of(:UncommunicativeVariableName)
 
-    it 'reports the correct values' do
-      expect(warning.parameters[:name]).to eq('x2')
-      expect(warning.lines).to eq([3, 5])
+      [[/bravo2/], /bravo2/, ['bravo2'], 'bravo2'].each do |pattern|
+        expect(src).to_not reek_of(:UncommunicativeVariableName).with_config('accept' => pattern)
+      end
     end
   end
 
-  context 'when a smell is reported in a singleton method' do
-    let(:warning) do
-      src = 'def self.bad() x2 = 4; end'
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::CodeContext.new(nil, syntax_tree)
-      detector.sniff(ctx).first
+  describe '`reject` patterns' do
+    let(:src) { 'def alfa; foobar = 42; end' }
+
+    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)
+      end
     end
+  end
+
+  describe '.default_config' do
+    it 'should merge in the default accept and reject patterns' do
+      expected = {
+        'enabled' => true,
+        'exclude' => [],
+        'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/],
+        'accept'  => [/^_$/]
+      }
 
-    it_should_behave_like 'common fields set correctly'
+      expect(described_class.default_config).to eq(expected)
+    end
+  end
 
-    it 'reports the fq context' do
-      expect(warning.context).to eq('self.bad')
+  describe '.contexts' do
+    it 'are scoped to classes, modules, instance and singleton methods' do
+      expect(described_class.contexts).to eq([:module, :class, :def, :defs])
     end
   end
 end

data/spec/reek/smells/unused_parameters_spec.rb

@@ -1,79 +1,103 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/unused_parameters'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UnusedParameters do
-  context 'for methods' do
-    it 'reports nothing for no parameters' do
-      expect('def simple; true end').not_to reek_of(:UnusedParameters)
-    end
+  it 'reports the right values' do
+    src = <<-EOS
+      def alfa(bravo)
+      end
+    EOS
+
+    expect(src).to reek_of(:UnusedParameters,
+                           lines:   [1],
+                           context: 'alfa',
+                           message: "has unused parameter 'bravo'",
+                           source:  'string',
+                           name:    'bravo')
+  end
 
-    it 'reports nothing for used parameter' do
-      expect('def simple(sum); sum end').not_to reek_of(:UnusedParameters)
-    end
+  it 'does count all occurences' do
+    src = <<-EOS
+      def alfa(bravo, charlie)
+      end
+    EOS
+
+    expect(src).to reek_of(:UnusedParameters,
+                           lines: [1],
+                           name:  'bravo')
+    expect(src).to reek_of(:UnusedParameters,
+                           lines: [1],
+                           name:  'charlie')
+  end
 
-    it 'reports for 1 used and 2 unused parameter' do
-      src = 'def simple(num,sum,denum); sum end'
-      expect(src).to reek_of(:UnusedParameters, name: 'num')
-      expect(src).to reek_of(:UnusedParameters, name: 'denum')
-    end
+  it 'reports nothing for no parameters' do
+    expect('def alfa; end').not_to reek_of(:UnusedParameters)
+  end
 
-    it 'reports for 3 used and 1 unused parameter' do
-      src = 'def simple(num,sum,denum,quotient); num + denum + sum end'
-      expect(src).to reek_of(:UnusedParameters,
-                             name: 'quotient')
-    end
+  it 'reports nothing for used parameter' do
+    expect('def alfa(bravo); bravo; end').not_to reek_of(:UnusedParameters)
+  end
 
-    it 'reports nothing for used splatted parameter' do
-      expect('def simple(*sum); sum end').not_to reek_of(:UnusedParameters)
-    end
+  it 'reports for 1 used and 2 unused parameter' do
+    src = 'def alfa(bravo, charlie, delta); bravo end'
 
-    it 'reports nothing for unused anonymous parameter' do
-      expect('def simple(_); end').not_to reek_of(:UnusedParameters)
-    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')
+  end
 
-    it 'reports nothing for named parameters prefixed with _' do
-      expect('def simple(_name); end').not_to reek_of(:UnusedParameters)
-    end
+  it 'reports nothing for named parameters prefixed with _' do
+    expect('def alfa(_bravo); end').not_to reek_of(:UnusedParameters)
+  end
 
-    it 'reports nothing for unused anonymous splatted parameter' do
-      expect('def simple(*); end').not_to reek_of(:UnusedParameters)
+  it 'reports nothing when using a parameter via self assignment' do
+    expect('def alfa(bravo); bravo += 1; end').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)
+  end
+
+  context 'using super' do
+    it 'reports nothing with implicit arguments' do
+      expect('def alfa(*bravo); super; end').not_to reek_of(:UnusedParameters)
     end
 
-    it 'reports nothing when using super with implicit arguments' do
-      expect('def simple(*args); super; end').not_to reek_of(:UnusedParameters)
+    it 'reports something when explicitely passing no arguments' do
+      expect('def alfa(*bravo); super(); end').to reek_of(:UnusedParameters)
     end
 
-    it 'reports something when using super explicitely passing no arguments' do
-      expect('def simple(*args); super(); end').to reek_of(:UnusedParameters)
+    it 'reports nothing when explicitely passing all arguments' do
+      expect('def alfa(*bravo); super(*bravo); end').not_to reek_of(:UnusedParameters)
     end
 
-    it 'reports nothing when using super explicitely passing all arguments' do
-      expect('def simple(*args); super(*args); end').not_to reek_of(:UnusedParameters)
+    it 'reports nothing in a nested context' do
+      expect('def alfa(*bravo); charlie(super); end').not_to reek_of(:UnusedParameters)
     end
+  end
 
-    it 'reports nothing when using super in a nested context' do
-      expect('def simple(*args); call_other("something", super); end').
-        not_to reek_of(:UnusedParameters)
+  context 'anonymous parameters' do
+    it 'reports nothing for unused anonymous parameter' do
+      expect('def alfa(_); end').not_to reek_of(:UnusedParameters)
     end
 
-    it 'reports something when not using a keyword argument with splat' do
-      expect('def simple(var, kw: :val, **args); @var, @kw = var, kw; end').
-        to reek_of(:UnusedParameters)
+    it 'reports nothing for unused anonymous splatted parameter' do
+      expect('def alfa(*); end').not_to reek_of(:UnusedParameters)
     end
+  end
 
-    it 'reports nothing when using a keyword argument with splat' do
-      expect('def simple(var, kw: :val, **args); @var, @kw, @args = var, kw, args; end').
-        not_to reek_of(:UnusedParameters)
+  context 'splatted parameters' do
+    it 'reports nothing for used splatted parameter' do
+      expect('def alfa(*bravo); bravo; end').not_to reek_of(:UnusedParameters)
     end
 
-    it 'reports nothing when using a parameter via self assignment' do
-      expect('def simple(counter); counter += 1; end').not_to reek_of(:UnusedParameters)
+    it 'reports something when not using a keyword argument with splat' do
+      expect('def alfa(**bravo); end').to reek_of(:UnusedParameters)
     end
 
-    it 'reports nothing when using a parameter on a rescue' do
-      expect('def simple(tries = 3); puts "nothing"; rescue; retry if tries -= 1 > 0; raise; end').
-        not_to reek_of(:UnusedParameters)
+    it 'reports nothing when using a keyword argument with splat' do
+      expect('def alfa(**bravo); bravo; end').not_to reek_of(:UnusedParameters)
     end
   end
 end