reek 6.0.2 → 6.0.6

data/spec/reek/smell_detectors/too_many_methods_spec.rb

@@ -1,54 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/too_many_methods'
-
-RSpec.describe Reek::SmellDetectors::TooManyMethods do
-  let(:config) do
-    { Reek::SmellDetectors::TooManyMethods::MAX_ALLOWED_METHODS_KEY => 3 }
-  end
-
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo; end
-        def charlie; end
-        def delta; end
-        def echo; end
-      end
-    RUBY
-
-    expect(src).to reek_of(:TooManyMethods,
-                           lines:   [1],
-                           context: 'Alfa',
-                           message: 'has at least 4 methods',
-                           source:  'string',
-                           count:   4).with_config(config)
-  end
-
-  it 'does not report if we stay below max_methods' do
-    src = <<-RUBY
-      class Alfa
-        def bravo; end
-        def charlie; end
-        def delta; end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyMethods).with_config(config)
-  end
-
-  it 'stops at a nested module' do
-    src = <<-RUBY
-      class Alfa
-        def bravo; end
-        def charlie; end
-
-        module Hidden
-          def delta; end
-          def echo; end
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyMethods).with_config(config)
-  end
-end

data/spec/reek/smell_detectors/too_many_statements_spec.rb

@@ -1,90 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/too_many_statements'
-
-RSpec.describe Reek::SmellDetectors::TooManyStatements do
-  let(:config) do
-    { Reek::SmellDetectors::TooManyStatements::MAX_ALLOWED_STATEMENTS_KEY => 2 }
-  end
-
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          charlie = 1
-          delta   = 2
-          echo    = 3
-        end
-      end
-    RUBY
-
-    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 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          charlie = 1
-          delta   = 2
-          echo    = 3
-        end
-
-        def foxtrot
-          golf  = 1
-          hotel = 2
-          india = 3
-        end
-      end
-    RUBY
-
-    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
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          charlie = 1
-          delta   = 2
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyStatements).with_config(config)
-  end
-
-  it 'does not report initialize' do
-    src = <<-RUBY
-      class Alfa
-        def initialize
-          charlie = 1
-          delta   = 2
-          echo    = 3
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyStatements).with_config(config)
-  end
-
-  it 'reports long inner block' do
-    src = <<-RUBY
-      def long
-        self.each do |x|
-          charlie = 1
-          delta   = 2
-          echo    = 3
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:TooManyStatements).with_config(config)
-  end
-end

data/spec/reek/smell_detectors/uncommunicative_method_name_spec.rb

@@ -1,78 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/uncommunicative_method_name'
-
-RSpec.describe Reek::SmellDetectors::UncommunicativeMethodName do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def m; end
-    RUBY
-
-    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
-      src = 'def a; end'
-      expect(src).to reek_of(:UncommunicativeMethodName)
-    end
-
-    it 'reports names ending with a digit' do
-      src = 'def xyz1; end'
-      expect(src).to reek_of(:UncommunicativeMethodName)
-    end
-
-    it 'reports camelcased names' do
-      src = 'def aBBa; end'
-      expect(src).to reek_of(:UncommunicativeMethodName)
-    end
-
-    it 'does not report one-letter special characters' do
-      ['+', '-', '/', '*'].each do |symbol|
-        expect("def #{symbol}; end").not_to reek_of(:UncommunicativeMethodName)
-      end
-    end
-  end
-
-  describe '`accept` patterns' do
-    let(:source) { 'def x; end' }
-
-    it 'make smelly names pass' do
-      pattern = /x/
-      expect(source).not_to reek_of(:UncommunicativeMethodName).with_config('accept' => pattern)
-    end
-  end
-
-  describe '`reject` patterns' do
-    let(:source) { 'def alfa; end' }
-
-    it 'reject smelly names' do
-      patterns = [/alf/, /lfa/]
-      patterns.each do |pattern|
-        expect(source).to reek_of(:UncommunicativeMethodName).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'  => [/^[a-z]$/, /[0-9]$/, /[A-Z]/],
-        'accept'  => []
-      }
-      expect(described_class.default_config).to eq(expected)
-    end
-  end
-
-  describe '.contexts' do
-    it 'is scoped to classes and modules' do
-      expect(described_class.contexts).to eq([:def, :defs])
-    end
-  end
-end

data/spec/reek/smell_detectors/uncommunicative_module_name_spec.rb

@@ -1,78 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/uncommunicative_module_name'
-
-RSpec.describe Reek::SmellDetectors::UncommunicativeModuleName do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class K
-      end
-    RUBY
-
-    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} Alfa; end").not_to reek_of(:UncommunicativeModuleName)
-      end
-
-      it 'reports one-letter name' do
-        expect("#{type} X; end").to reek_of(:UncommunicativeModuleName, name: 'X')
-      end
-
-      it 'reports name of the form "x2"' do
-        expect("#{type} X2; end").to reek_of(:UncommunicativeModuleName, name: 'X2')
-      end
-
-      it 'reports long name ending in a number' do
-        expect("#{type} Alfa2; end").to reek_of(:UncommunicativeModuleName, name: 'Alfa2')
-      end
-    end
-  end
-
-  describe '`accept` patterns' do
-    let(:source) { 'class Alfa1; end' }
-
-    it 'make smelly names pass ' do
-      patterns = [/lfa1/, /Alfa1/]
-      patterns.each do |pattern|
-        expect(source).not_to reek_of(:UncommunicativeModuleName).with_config('accept' => pattern)
-      end
-    end
-  end
-
-  describe '`reject` patterns' do
-    let(:source) { 'class Alfa; end' }
-
-    it 'reject smelly names' do
-      patterns = [/lfa/, /Alf/]
-      patterns.each do |pattern|
-        expect(source).to reek_of(:UncommunicativeModuleName).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]$/],
-        'accept'  => []
-      }
-      expect(described_class.default_config).to eq(expected)
-    end
-  end
-
-  describe '.contexts' do
-    it 'indicates that this smell is scoped to classes and modules' do
-      expect(described_class.contexts).to eq([:module, :class])
-    end
-  end
-end

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