reek 6.0.3 → 6.1.0

data/spec/reek/smell_detectors/uncommunicative_parameter_name_spec.rb

@@ -1,147 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/uncommunicative_parameter_name'
-
-RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa(x)
-        x
-      end
-    RUBY
-
-    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 = <<-RUBY
-      def alfa(x, y)
-        [x, y]
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:UncommunicativeParameterName, lines: [1], name: 'x').
-      and reek_of(:UncommunicativeParameterName, lines: [1], name: 'y')
-  end
-
-  { 'alfa.' => 'with a receiver',
-    ''      => 'without a receiver' }.each do |host, description|
-    context "in a method definition #{description}" do
-      it 'does not report two-letter parameter names' do
-        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}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}bravo(param2) charlie(param2) end"
-        expect(src).to reek_of(:UncommunicativeParameterName, name: 'param2')
-      end
-
-      it 'reports unused parameters' do
-        src = "def #{host}bravo(x); charlie; end"
-        expect(src).to reek_of(:UncommunicativeParameterName)
-      end
-
-      it 'reports splat parameters' do
-        expect("def #{host}bravo(*a); charlie(a); end").
-          to reek_of(:UncommunicativeParameterName, name: 'a')
-      end
-
-      it 'reports double splat parameters' do
-        expect("def #{host}bravo(**a); charlie(a); end").
-          to reek_of(:UncommunicativeParameterName, name: 'a')
-      end
-
-      it 'reports block parameters' do
-        expect("def #{host}bravo(&a); charlie(a); end").
-          to reek_of(:UncommunicativeParameterName, name: 'a')
-      end
-
-      it 'does not report unused anonymous parameter' do
-        src = "def #{host}bravo(_); charlie; end"
-        expect(src).not_to reek_of(:UncommunicativeParameterName)
-      end
-
-      it 'reports used anonymous parameter' do
-        src = "def #{host}bravo(_); charlie(_) end"
-        expect(src).to reek_of(:UncommunicativeParameterName, name: '_')
-      end
-
-      it 'reports used parameters marked as unused' do
-        src = "def #{host}bravo(_unused) charlie(_unused) end"
-        expect(src).to reek_of(:UncommunicativeParameterName, name: '_unused')
-      end
-
-      it 'does not report anonymous splat' do
-        expect("def #{host}bravo(*); end").not_to reek_of(:UncommunicativeParameterName)
-      end
-
-      it 'does not report anonymous double splat' do
-        expect("def #{host}bravo(**); end").not_to reek_of(:UncommunicativeParameterName)
-      end
-
-      it 'reports names inside array decomposition' do
-        src = "def #{host}bravo((x, charlie)) delta(x, charlie) end"
-        expect(src).to reek_of(:UncommunicativeParameterName,
-                               name: 'x')
-      end
-
-      it 'reports names inside nested array decomposition' do
-        src = "def #{host}bravo((charlie, (delta, x))) echo(charlie, x) end"
-        expect(src).to reek_of(:UncommunicativeParameterName,
-                               name: 'x')
-      end
-    end
-  end
-
-  describe '`accept` patterns' do
-    let(:source) { 'def alfa(bar2); charlie(bar2); end' }
-
-    it 'make smelly names pass' do
-      patterns = [/bar2/, /ar2/]
-      patterns.each do |pattern|
-        expect(source).not_to reek_of(:UncommunicativeParameterName).with_config('accept' => pattern)
-      end
-    end
-  end
-
-  describe '`reject` patterns' do
-    let(:source) { 'def alfa(bravo); charlie(bravo); end' }
-
-    it 'reject smelly names' do
-      patterns = [/brav/, /ravo/]
-      patterns.each do |pattern|
-        expect(source).to reek_of(:UncommunicativeParameterName).with_config('reject' => pattern)
-      end
-    end
-  end
-
-  describe '.default_config' do
-    it 'merges in the default accept and reject patterns' do
-      expected = {
-        'enabled' => true,
-        'exclude' => [],
-        'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/, /^_/],
-        'accept'  => []
-      }
-
-      expect(described_class.default_config).to eq(expected)
-    end
-  end
-
-  describe '.contexts' do
-    it 'indicates that this smell is scoped to method definitions' do
-      expect(described_class.contexts).to eq([:def, :defs])
-    end
-  end
-end

data/spec/reek/smell_detectors/uncommunicative_variable_name_spec.rb

@@ -1,201 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/uncommunicative_variable_name'
-
-RSpec.describe Reek::SmellDetectors::UncommunicativeVariableName do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa
-        x = 5
-      end
-    RUBY
-
-    expect(src).to reek_of(:UncommunicativeVariableName,
-                           lines:   [2],
-                           context: 'alfa',
-                           message: "has the variable name 'x'",
-                           source:  'string',
-                           name:    'x')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      def alfa
-        x = 3
-        y = 7
-      end
-    RUBY
-
-    expect(src).to reek_of(:UncommunicativeVariableName, lines: [2], name: 'x').
-      and reek_of(:UncommunicativeVariableName, lines: [3], name: 'y')
-  end
-
-  context 'when examining 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 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 'when examining local variables' do
-    it 'does not report single underscore as a variable name' do
-      src = 'def alfa; _ = bravo(); end'
-      expect(src).not_to reek_of(:UncommunicativeVariableName)
-    end
-
-    it 'reports one-letter names' do
-      src = 'def alfa; x = bravo(); end'
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-    end
-
-    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 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 alfa; bravo.each { x = 42 }; end'
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-    end
-
-    it 'reports variable name outside any method' do
-      src = 'class Alfa; x = bravo(); end'
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-    end
-
-    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 'when examining block parameters' do
-    it 'reports all relevant block parameters' do
-      src = <<-RUBY
-        def alfa
-          @bravo.map { |x, y| x + y }
-        end
-      RUBY
-
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x').
-        and reek_of(:UncommunicativeVariableName, name: 'y')
-    end
-
-    it 'reports block parameters used outside of methods' do
-      src = <<-RUBY
-        class Alfa
-          @bravo.map { |x| x * 2 }
-        end
-      RUBY
-
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
-    end
-
-    it 'reports splatted block parameters correctly' do
-      src = <<-RUBY
-        def alfa
-          @bravo.map { |*y| y << 1 }
-        end
-      RUBY
-
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
-    end
-
-    it 'reports nested block parameters' do
-      src = <<-RUBY
-        def alfa
-          @bravo.map { |(x, y)| x + y }
-        end
-      RUBY
-
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x').
-        and reek_of(:UncommunicativeVariableName, name: 'y')
-    end
-
-    it 'reports splatted nested block parameters' do
-      src = <<-RUBY
-        def def alfa
-          @bravo.map { |(x, *y)| x + y }
-        end
-      RUBY
-
-      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x').
-        and reek_of(:UncommunicativeVariableName, name: 'y')
-    end
-
-    it 'reports deeply nested block parameters' do
-      src = <<-RUBY
-        def alfa
-          @bravo.map { |(x, (y, z))| x + y + z }
-        end
-      RUBY
-
-      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
-      src = <<-RUBY
-        def alfa
-          @bravo.map { |x; y| y = x * 2 }
-        end
-      RUBY
-
-      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' }
-
-    it 'make smelly names pass' do
-      patterns = [/ravo2/, /bravo2/]
-      patterns.each do |pattern|
-        expect(src).to reek_of(:UncommunicativeVariableName).
-          and not_reek_of(:UncommunicativeVariableName).with_config('accept' => pattern)
-      end
-    end
-  end
-
-  describe '`reject` patterns' do
-    let(:src) { 'def alfa; foobar = 42; end' }
-
-    it 'reject smelly names' do
-      patterns = [/fooba/, /oobar/]
-      patterns.each do |pattern|
-        expect(src).to not_reek_of(:UncommunicativeVariableName).
-          and reek_of(:UncommunicativeVariableName).with_config('reject' => pattern)
-      end
-    end
-  end
-
-  describe '.default_config' do
-    it 'merges in the default accept and reject patterns' do
-      expected = {
-        'enabled' => true,
-        'exclude' => [],
-        'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/],
-        'accept'  => [/^_$/]
-      }
-
-      expect(described_class.default_config).to eq(expected)
-    end
-  end
-
-  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/smell_detectors/unused_parameters_spec.rb

@@ -1,114 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/unused_parameters'
-
-RSpec.describe Reek::SmellDetectors::UnusedParameters do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa(bravo)
-      end
-    RUBY
-
-    expect(src).to reek_of(:UnusedParameters,
-                           lines:   [1],
-                           context: 'alfa',
-                           message: "has unused parameter 'bravo'",
-                           source:  'string',
-                           name:    'bravo')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      def alfa(bravo, charlie)
-      end
-    RUBY
-
-    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
-    src = 'def alfa; end'
-    expect(src).not_to reek_of(:UnusedParameters)
-  end
-
-  it 'reports nothing for used parameter' do
-    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).
-      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
-    src = 'def alfa(_bravo); end'
-    expect(src).not_to reek_of(:UnusedParameters)
-  end
-
-  it 'reports nothing when using a parameter via self assignment' do
-    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
-    src = 'def alfa(bravo = 3); puts "nothing"; rescue; retry if bravo -= 1 > 0; raise; end'
-    expect(src).not_to reek_of(:UnusedParameters)
-  end
-
-  context 'when using super' do
-    it 'reports nothing with implicit arguments' do
-      src = 'def alfa(*bravo); super; end'
-      expect(src).not_to reek_of(:UnusedParameters)
-    end
-
-    it 'reports something when explicitely passing no arguments' do
-      src = 'def alfa(*bravo); super(); end'
-      expect(src).to reek_of(:UnusedParameters)
-    end
-
-    it 'reports nothing when explicitely passing all arguments' do
-      src = 'def alfa(*bravo); super(*bravo); end'
-      expect(src).not_to reek_of(:UnusedParameters)
-    end
-
-    it 'reports nothing in a nested context' do
-      src = 'def alfa(*bravo); charlie(super); end'
-      expect(src).not_to reek_of(:UnusedParameters)
-    end
-  end
-
-  context 'with anonymous parameters' do
-    it 'reports nothing for unused anonymous parameter' do
-      src = 'def alfa(_); end'
-      expect(src).not_to reek_of(:UnusedParameters)
-    end
-
-    it 'reports nothing for unused anonymous splatted parameter' do
-      src = 'def alfa(*); end'
-      expect(src).not_to reek_of(:UnusedParameters)
-    end
-  end
-
-  context 'with splatted parameters' do
-    it 'reports nothing for used splatted parameter' do
-      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
-      src = 'def alfa(**bravo); end'
-      expect(src).to reek_of(:UnusedParameters)
-    end
-
-    it 'reports nothing when using a keyword argument with splat' do
-      src = 'def alfa(**bravo); bravo; end'
-      expect(src).not_to reek_of(:UnusedParameters)
-    end
-  end
-end

data/spec/reek/smell_detectors/unused_private_method_spec.rb

@@ -1,205 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/unused_private_method'
-
-RSpec.describe Reek::SmellDetectors::UnusedPrivateMethod do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        private
-
-        def charlie
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:UnusedPrivateMethod,
-                           lines:   [4],
-                           context: 'Alfa',
-                           message: "has the unused private instance method 'charlie'",
-                           source:  'string',
-                           name:    'charlie')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        private
-
-        def charlie
-        end
-
-        def charlie
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:UnusedPrivateMethod, lines: [4], name: 'charlie').
-      and reek_of(:UnusedPrivateMethod, lines: [7], name: 'charlie')
-  end
-
-  context 'when a class has unused private methods' do
-    it 'reports instance methods' do
-      source = <<-RUBY
-        class Alfa
-          private
-          def bravo; end
-          def charlie; end
-        end
-      RUBY
-
-      expect(source).
-        to reek_of(:UnusedPrivateMethod, name: 'bravo').
-        and reek_of(:UnusedPrivateMethod, name: 'charlie')
-    end
-
-    it 'reports instance methods in the correct class' do
-      source = <<-RUBY
-        class Alfa
-          class Bravo
-            private
-            def charlie; end
-          end
-        end
-      RUBY
-
-      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
-      source = <<-RUBY
-        class Alfa
-          class Bravo
-            def bravo
-              charlie
-            end
-
-            private
-            def charlie; end
-          end
-
-          private
-          def charlie; end
-        end
-      RUBY
-
-      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
-      source = <<-RUBY
-        class Alfa
-          private
-          def bravo; end
-          def charlie; end
-        end
-      RUBY
-
-      expect(source).
-        to reek_of(:UnusedPrivateMethod, name: 'bravo', lines: [3]).
-        and reek_of(:UnusedPrivateMethod, name: 'charlie', lines: [4])
-    end
-
-    it 'reports instance methods defined as private with a modifier' do
-      source = <<-RUBY
-        class Alfa
-          private def bravo; end
-        end
-      RUBY
-
-      expect(source).
-        to reek_of(:UnusedPrivateMethod, name: 'bravo')
-    end
-  end
-
-  context 'when the detector is configured via a source code comment' do
-    it 'does not report methods we excluded' do
-      source = <<-RUBY
-        # :reek:UnusedPrivateMethod { exclude: [ bravo ] }
-        class Alfa
-          private
-          def bravo; end
-          def charlie; end
-        end
-      RUBY
-
-      expect(source).
-        to reek_of(:UnusedPrivateMethod, name: 'charlie').
-        and not_reek_of(:UnusedPrivateMethod, name: 'bravo')
-    end
-  end
-
-  context 'when a class has only used private methods' do
-    it 'reports nothing' do
-      source = <<-RUBY
-        class Alfa
-          def bravo
-            charlie
-          end
-
-          private
-          def charlie; end
-        end
-      RUBY
-
-      expect(source).not_to reek_of(:UnusedPrivateMethod)
-    end
-  end
-
-  context 'when a class has unused protected methods' do
-    it 'reports nothing' do
-      source = <<-RUBY
-        class Alfa
-          protected
-          def bravo; end
-        end
-      RUBY
-
-      expect(source).not_to reek_of(:UnusedPrivateMethod)
-    end
-  end
-
-  context 'when a class has unused public methods' do
-    it 'reports nothing' do
-      source = <<-RUBY
-        class Alfa
-          def bravo; end
-        end
-      RUBY
-
-      expect(source).not_to reek_of(:UnusedPrivateMethod)
-    end
-  end
-
-  describe 'preventing methods from being reported' do
-    let(:source) do
-      <<-RUBY
-        class Alfa
-          private
-          def bravo; end
-          def charlie; end
-        end
-      RUBY
-    end
-
-    it 'excludes them via direct match in the app configuration' do
-      config = { Reek::SmellDetectors::BaseDetector::EXCLUDE_KEY => ['Alfa#charlie'] }
-
-      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::SmellDetectors::BaseDetector::EXCLUDE_KEY => [/charlie/] }
-
-      expect(source).
-        to reek_of(:UnusedPrivateMethod, name: 'bravo').with_config(config).
-        and not_reek_of(:UnusedPrivateMethod, name: 'charlie').with_config(config)
-    end
-  end
-end