reek 6.0.2 → 6.1.0

data/spec/reek/smell_detectors/too_many_constants_spec.rb

@@ -1,144 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/too_many_constants'
-
-RSpec.describe Reek::SmellDetectors::TooManyConstants do
-  let(:config) do
-    { Reek::SmellDetectors::TooManyConstants::MAX_ALLOWED_CONSTANTS_KEY => 2 }
-  end
-
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        Bravo = Charlie = Delta = 1
-      end
-    RUBY
-
-    expect(src).to reek_of(:TooManyConstants,
-                           lines:   [1],
-                           context: 'Alfa',
-                           message: 'has 3 constants',
-                           source:  'string',
-                           count:   3).with_config(config)
-  end
-
-  it 'does not report for non-excessive constants' do
-    src = <<-RUBY
-      class Alfa
-        Bravo = Charlie = 1
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
-  end
-
-  it 'does not report when increasing default' do
-    src = <<-RUBY
-      # :reek:TooManyConstants { max_constants: 3 }
-      class Alfa
-        Bravo = Charlie = Delta = 1
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
-  end
-
-  it 'does not report when disabled' do
-    src = <<-RUBY
-      # :reek:TooManyConstants { enabled: false }
-      class Alfa
-        Bravo = Charlie = Delta = 1
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
-  end
-
-  it 'does not account class definition' do
-    src = <<-RUBY
-      class Alfa
-        Bravo = Charlie = 1
-        Delta = Class.new(StandardError)
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
-  end
-
-  it 'does not account struct definition' do
-    src = <<-RUBY
-      class Alfa
-        Bravo = Charlie = 1
-        Delta = Struct.new
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
-  end
-
-  it 'counts each constant only once' do
-    src = <<-RUBY
-      class Alfa
-        Bravo = Charlie = 1
-      end
-
-      class Delta
-        Echo = Foxtrot = 1
-      end
-
-      class Golf
-        Hotel = India = 1
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
-  end
-
-  it 'does not report outer module when inner module suppressed' do
-    src = <<-RUBY
-      module Alfa
-        # ignore :reek:TooManyConstants
-        module Bravo
-          Charlie = Delta = Echo = 1
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
-  end
-
-  it 'counts each constant only once for each namespace' do
-    src = <<-RUBY
-      module Alfa
-        Bravo = Charlie = 1
-
-        class Delta
-          Echo = 1
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyConstants).with_config(config)
-  end
-
-  it 'reports for excessive constants inside a module' do
-    src = <<-RUBY
-      module Alfa
-        Bravo = Charlie = Delta = 1
-      end
-    RUBY
-
-    expect(src).to reek_of(:TooManyConstants, context: 'Alfa').with_config(config)
-  end
-
-  it 'reports the full class name' do
-    src = <<-RUBY
-      module Alfa
-        class Bravo
-          Charlie = Delta = Echo = 1
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:TooManyConstants, context: 'Alfa::Bravo').with_config(config)
-  end
-end

data/spec/reek/smell_detectors/too_many_instance_variables_spec.rb

@@ -1,132 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/too_many_instance_variables'
-
-RSpec.describe Reek::SmellDetectors::TooManyInstanceVariables do
-  let(:config) do
-    { Reek::SmellDetectors::TooManyInstanceVariables::MAX_ALLOWED_IVARS_KEY => 2 }
-  end
-
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          @charlie = @delta = @echo = 1
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:TooManyInstanceVariables,
-                           lines:   [1],
-                           context: 'Alfa',
-                           message: 'has at least 3 instance variables',
-                           source:  'string',
-                           count:   3).with_config(config)
-  end
-
-  it 'does not report for non-excessive ivars' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          @charlie = @delta = 1
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
-  end
-
-  it 'has a configurable maximum' do
-    src = <<-RUBY
-      # :reek:TooManyInstanceVariables { max_instance_variables: 3 }
-      class Alfa
-        def bravo
-          @charlie = @delta = @echo = 1
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
-  end
-
-  it 'counts each ivar only once' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          @charlie = @delta = 1
-          @charlie = @delta = 1
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
-  end
-
-  it 'does not report memoized bravo' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          @charlie = @delta = 1
-          @echo ||= 1
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
-  end
-
-  it 'does not count ivars across inner classes' do
-    src = <<-RUBY
-      class Alfa
-        class Bravo
-          def charlie
-            @delta = @echo = 1
-          end
-        end
-
-        class Hotel
-          def india
-            @juliett = 1
-          end
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
-  end
-
-  it 'does not count ivars across inner modules and classes' do
-    src = <<-RUBY
-      class Alfa
-        class Bravo
-          def charlie
-            @delta = @echo = 1
-          end
-        end
-
-        module Foxtrot
-          def golf
-            @hotel = 1
-          end
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:TooManyInstanceVariables).with_config(config)
-  end
-
-  it 'reports excessive ivars across different methods' do
-    src = <<-RUBY
-      class Alfa
-        def bravo
-          @charlie = @delta = 1
-        end
-
-        def golf
-          @hotel = 1
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:TooManyInstanceVariables).with_config(config)
-  end
-end

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