reek 6.0.2 → 6.5.0

data/spec/reek/smell_detectors/nested_iterators_spec.rb

@@ -1,333 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/nested_iterators'
-
-RSpec.describe Reek::SmellDetectors::NestedIterators do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.each do |charlie|
-          charlie.each { |delta| delta }
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:NestedIterators,
-                           lines:   [3],
-                           context: 'alfa',
-                           message: 'contains iterators nested 2 deep',
-                           source:  'string',
-                           depth:   2)
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      def alfa
-        bravo.each do |charlie|
-          charlie.each { |delta| delta }
-        end
-
-        echo.each do |foxtrot|
-          foxtrot.each do |golf|
-            golf.each { |hotel| hotel }
-          end
-        end
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:NestedIterators, lines: [3], depth: 2).
-      and reek_of(:NestedIterators, lines: [8], depth: 3)
-  end
-
-  it 'reports no smells with no iterators' do
-    src = 'def alfa; end'
-    expect(src).not_to reek_of(:NestedIterators)
-  end
-
-  it 'reports no smells with one iterator' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.each { |charlie| charlie }
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:NestedIterators)
-  end
-
-  it 'does not report nested iterators for Object#tap' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.tap do |charlie|
-          charlie.each { |delta| delta }
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:NestedIterators)
-  end
-
-  it 'does not report method with successive iterators' do
-    src = <<-RUBY
-      def alfa
-        @bravo.each   { |charlie| charlie }
-        @charlie.each { |delta| delta }
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:NestedIterators)
-  end
-
-  it 'does not report method with chained iterators' do
-    src = <<-RUBY
-      def alfa
-        bravo.sort_by { |charlie| charlie }.each { |delta| delta }
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:NestedIterators)
-  end
-
-  it 'detects an iterator with an empty block' do
-    src = <<-RUBY
-      def alfa
-        bravo do |charlie|
-          charlie { |delta| }
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:NestedIterators)
-  end
-
-  it 'reports nesting inside iterator arguments' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo(
-          charlie.each do |delta|
-            delta.each { |echo| echo }
-          end
-        )
-      end
-    RUBY
-
-    expect(src).to reek_of(:NestedIterators, depth: 2)
-  end
-
-  it 'reports the deepest level of nesting only' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.each do |charlie|
-          charlie.each do |delta|
-            delta.each { |echo| echo }
-          end
-        end
-      end
-    RUBY
-
-    expect(src).
-      to not_reek_of(:NestedIterators, depth: 2).
-      and reek_of(:NestedIterators, depth: 3, lines: [4])
-  end
-
-  it 'reports all lines on which nested iterators occur' do
-    source = <<-RUBY
-      def alfa
-        @bravo.each { |charlie| charlie.each { |delta| @echo.send } }
-        @foxtrot.each { |golf| golf.each { |hotel| @india.send } }
-      end
-    RUBY
-
-    expect(source).to reek_of(:NestedIterators, lines: [2, 3])
-  end
-
-  it 'handles the case where super receives a block' do
-    src = <<-RUBY
-      def alfa
-        super do |bravo|
-          bravo.each { |charlie| charlie }
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:NestedIterators)
-  end
-
-  it 'handles the case where super receives a block and arguments' do
-    src = <<-RUBY
-      def alfa
-        super(delta) do |bravo|
-          bravo.each { |charlie| charlie }
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:NestedIterators)
-  end
-
-  it 'does not count iterators without block arguments' do
-    src = <<-RUBY
-      def alfa
-        bravo do
-          charlie.each { |delta| delta }
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:NestedIterators)
-  end
-
-  context 'when blocks are specified as lambdas' do
-    it 'does not report blocks that are not nested' do
-      src = <<-RUBY
-        def alfa
-          bravo ->(charlie) { delta }
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:NestedIterators)
-    end
-
-    it 'reports blocks that are nested' do
-      src = <<-RUBY
-        def alfa
-          bravo ->(charlie) do
-            delta ->(echo) { echo }
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:NestedIterators)
-    end
-  end
-
-  it 'reports nested iterators called via safe navigation' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo&.each do |charlie|
-          charlie&.each { |delta| delta }
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:NestedIterators)
-  end
-
-  it 'does not report unnested iterators called via safe navigation' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo&.each { |charlie| charlie }
-        delta&.each { |echo| echo }
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:NestedIterators)
-  end
-
-  context 'when setting the allowed nesting depth to 3' do
-    let(:config) do
-      { Reek::SmellDetectors::NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 }
-    end
-
-    it 'does not report nested iterators 3 levels deep' do
-      src = <<-RUBY
-        def alfa(bravo)
-          bravo.each do |charlie|
-            charlie.each do |delta|
-              delta.each { |echo| echo }
-            end
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:NestedIterators).with_config(config)
-    end
-
-    it 'reports nested iterators 4 levels deep' do
-      src = <<-RUBY
-        def alfa(bravo)
-          bravo.each do |charlie|
-            charlie.each do |delta|
-              delta.each do |echo|
-                echo.each { |foxtrot| foxtrot }
-              end
-            end
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:NestedIterators).with_config(config)
-    end
-  end
-
-  context 'when ignoring iterators' do
-    let(:config) do
-      { Reek::SmellDetectors::NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me'] }
-    end
-
-    it 'does not report when nesting the ignored iterator inside another' do
-      src = <<-RUBY
-        def alfa(bravo)
-          bravo.each do |charlie|
-            charlie.ignore_me { |delta| delta }
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:NestedIterators).with_config(config)
-    end
-
-    it 'does not report a nested iterator inside the ignored iterator' do
-      src = <<-RUBY
-        def alfa(bravo)
-          bravo.ignore_me do |charlie|
-            charlie.each { |delta| delta }
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:NestedIterators).with_config(config)
-    end
-
-    it 'reports nested iterators inside the ignored iterator' do
-      src = <<-RUBY
-        def alfa(bravo)
-          bravo.ignore_me do |charlie|
-            charlie.each do |delta|
-              delta.each { |echo| echo }
-            end
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:NestedIterators, depth: 2).with_config(config)
-    end
-
-    it 'reports nested iterators outside the ignored iterator' do
-      src = <<-RUBY
-        def alfa(bravo)
-          bravo.each do |charlie|
-            charlie.each do |delta|
-              delta.ignore_me { |echo| echo }
-            end
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:NestedIterators, depth: 2).with_config(config)
-    end
-
-    it 'reports nested iterators with the ignored iterator between them' do
-      src = <<-RUBY
-        def alfa(bravo)
-          bravo.each do |charlie|
-            charlie.ignore_me do |delta|
-              delta.each { |echo| echo }
-            end
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:NestedIterators, depth: 2).with_config(config)
-    end
-  end
-end

data/spec/reek/smell_detectors/nil_check_spec.rb

@@ -1,100 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/nil_check'
-
-RSpec.describe Reek::SmellDetectors::NilCheck do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.nil?
-      end
-    RUBY
-
-    expect(src).to reek_of(:NilCheck,
-                           lines:   [2],
-                           context: 'alfa',
-                           message: 'performs a nil-check',
-                           source:  'string')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      def alfa(bravo, charlie)
-        bravo.nil?
-        charlie.nil?
-      end
-    RUBY
-
-    expect(src).to reek_of(:NilCheck,
-                           lines:   [2, 3],
-                           context: 'alfa')
-  end
-
-  it 'reports nothing when scope includes no nil checks' do
-    src = 'def alfa; end'
-    expect(src).not_to reek_of(:NilCheck)
-  end
-
-  it 'reports when scope uses == nil' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo == nil
-      end
-    RUBY
-
-    expect(src).to reek_of(:NilCheck)
-  end
-
-  it 'reports when scope uses === nil' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo === nil
-      end
-    RUBY
-
-    expect(src).to reek_of(:NilCheck)
-  end
-
-  it 'reports when scope uses nil ==' do
-    src = <<-RUBY
-      def alfa(bravo)
-        nil == bravo
-      end
-    RUBY
-
-    expect(src).to reek_of(:NilCheck)
-  end
-
-  it 'reports when scope uses a case-clause checking nil' do
-    src = <<-RUBY
-      def alfa(bravo)
-        case bravo
-        when nil then puts "Nil"
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:NilCheck)
-  end
-
-  it 'does not report when scope uses &.' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo&.charlie
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:NilCheck)
-  end
-
-  it 'reports all lines when scope uses multiple nilchecks' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.nil?
-        @charlie === nil
-        delta&.echo
-      end
-    RUBY
-
-    expect(src).to reek_of(:NilCheck, lines: [2, 3])
-  end
-end

data/spec/reek/smell_detectors/repeated_conditional_spec.rb

@@ -1,100 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/repeated_conditional'
-
-RSpec.describe Reek::SmellDetectors::RepeatedConditional do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        attr_accessor :bravo
-
-        def charlie
-          puts "Repeat 1!" if bravo
-        end
-
-        def delta
-          puts "Repeat 2!" if bravo
-        end
-
-        def echo
-          puts "Repeat 3!" if bravo
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:RepeatedConditional,
-                           lines:   [5, 9, 13],
-                           context: 'Alfa',
-                           message: "tests 'bravo' at least 3 times",
-                           source:  'string',
-                           name:    'bravo',
-                           count:   3)
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        attr_accessor :bravo
-
-        def charlie
-          puts "Repeat 1!" if bravo
-          puts "And again!" if bravo
-        end
-
-        def delta
-          puts "Repeat 2!" if bravo
-        end
-
-        def echo
-          puts "Repeat 3!" if bravo
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:RepeatedConditional,
-                           lines: [5, 6, 10, 14],
-                           count: 4)
-  end
-
-  it 'does not report two repeated conditionals' do
-    src = <<-RUBY
-      class Alfa
-        attr_accessor :bravo
-
-        def charlie
-          puts "Repeat 1!" if bravo
-        end
-
-        def delta
-          puts "Repeat 2!" if bravo
-        end
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:RepeatedConditional)
-  end
-
-  it 'reports repeated conditionals regardless of `if` or `case` statements' do
-    src = <<-RUBY
-      class Alfa
-        attr_accessor :bravo
-
-        def charlie
-          puts "Repeat 1!" if bravo
-        end
-
-        def delta
-          case bravo
-          when 1 then puts "Repeat 2!"
-          else 'nothing'
-          end
-        end
-
-        def echo
-          puts "Repeat 3!" if bravo
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:RepeatedConditional)
-  end
-end

data/spec/reek/smell_detectors/subclassed_from_core_class_spec.rb

@@ -1,77 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/subclassed_from_core_class'
-
-RSpec.describe Reek::SmellDetectors::SubclassedFromCoreClass do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa < Hash
-      end
-    RUBY
-
-    expect(src).to reek_of(:SubclassedFromCoreClass,
-                           lines:    [1],
-                           context:  'Alfa',
-                           message:  "inherits from core class 'Hash'",
-                           source:   'string',
-                           ancestor: 'Hash')
-  end
-
-  it 'reports when inheriting from a core class inside a module' do
-    src = <<-RUBY
-      module Alfa
-        class Bravo < Hash
-        end
-      end
-    RUBY
-
-    expect(src).to reek_of(:SubclassedFromCoreClass, context: 'Alfa::Bravo')
-  end
-
-  it 'does not report when not inheriting from a core class' do
-    src = <<-RUBY
-      class Alfa
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:SubclassedFromCoreClass)
-  end
-
-  it 'does not report on coincidental core class names in other namespaces' do
-    src = <<-RUBY
-      class Alfa < Bravo::Array
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:SubclassedFromCoreClass)
-  end
-
-  it 'reports if inner class inherit from a core class' do
-    src = <<-RUBY
-      class Alfa
-        Bravo = Class.new(Array)
-      end
-    RUBY
-
-    expect(src).to reek_of(:SubclassedFromCoreClass, context: 'Alfa::Bravo')
-  end
-
-  it 'reports class which inherits from core class via Class.new' do
-    src = 'Alfa = Class.new(Array)'
-    expect(src).to reek_of(:SubclassedFromCoreClass)
-  end
-
-  it 'does not report class which inherits from allowed class via Class.new' do
-    src = 'Alfa = Class.new(StandardError)'
-    expect(src).not_to reek_of(:SubclassedFromCoreClass)
-  end
-
-  it 'does not report classes created with Struct.new' do
-    src = "Alfa = Struct.new('Array')"
-    expect(src).not_to reek_of(:SubclassedFromCoreClass)
-  end
-
-  it 'does not report class created by another class constructor taking a core class as argument' do
-    src = 'Charlie = Delta.new(Array)'
-    expect(src).not_to reek_of(:SubclassedFromCoreClass)
-  end
-end