rubocop-rspec 1.7.0 → 3.0.2

data/lib/rubocop/cop/rspec/empty_hook.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for empty before and after hooks.
+      #
+      # @example
+      #   # bad
+      #   before {}
+      #   after do; end
+      #   before(:all) do
+      #   end
+      #   after(:all) { }
+      #
+      #   # good
+      #   before { create_users }
+      #   after do
+      #     cleanup_users
+      #   end
+      #   before(:all) do
+      #     create_feed
+      #   end
+      #   after(:all) { cleanup_feed }
+      #
+      class EmptyHook < Base
+        extend AutoCorrector
+        include RuboCop::Cop::RangeHelp
+
+        MSG = 'Empty hook detected.'
+
+        # @!method empty_hook?(node)
+        def_node_matcher :empty_hook?, <<~PATTERN
+          (block $(send nil? #Hooks.all ...) _ nil?)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          empty_hook?(node) do |hook|
+            add_offense(hook) do |corrector|
+              corrector.remove(
+                range_with_surrounding_space(node.source_range, side: :left)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_line_after_example.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after example blocks.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe Foo do
+      #     it 'does this' do
+      #     end
+      #     it 'does that' do
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe Foo do
+      #     it 'does this' do
+      #     end
+      #
+      #     it 'does that' do
+      #     end
+      #   end
+      #
+      #   # fair - it's ok to have non-separated one-liners
+      #   RSpec.describe Foo do
+      #     it { one }
+      #     it { two }
+      #   end
+      #
+      # @example with AllowConsecutiveOneLiners configuration
+      #   # rubocop.yml
+      #   # RSpec/EmptyLineAfterExample:
+      #   #   AllowConsecutiveOneLiners: false
+      #
+      #   # bad
+      #   RSpec.describe Foo do
+      #     it { one }
+      #     it { two }
+      #   end
+      #
+      class EmptyLineAfterExample < Base
+        extend AutoCorrector
+        include EmptyLineSeparation
+
+        MSG = 'Add an empty line after `%<example>s`.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example?(node)
+          return if allowed_one_liner?(node)
+
+          missing_separating_line_offense(node) do |method|
+            format(MSG, example: method)
+          end
+        end
+
+        private
+
+        def allowed_one_liner?(node)
+          consecutive_one_liner?(node) && allow_consecutive_one_liners?
+        end
+
+        def allow_consecutive_one_liners?
+          cop_config['AllowConsecutiveOneLiners']
+        end
+
+        def consecutive_one_liner?(node)
+          node.single_line? && next_one_line_example?(node)
+        end
+
+        def next_one_line_example?(node)
+          next_sibling = node.right_sibling
+          return false unless next_sibling
+          return false unless example?(next_sibling)
+
+          next_sibling.single_line?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_line_after_example_group.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after example group blocks.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe Foo do
+      #     describe '#bar' do
+      #     end
+      #     describe '#baz' do
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe Foo do
+      #     describe '#bar' do
+      #     end
+      #
+      #     describe '#baz' do
+      #     end
+      #   end
+      #
+      class EmptyLineAfterExampleGroup < Base
+        extend AutoCorrector
+        include EmptyLineSeparation
+
+        MSG = 'Add an empty line after `%<example_group>s`.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless spec_group?(node)
+
+          missing_separating_line_offense(node) do |method|
+            format(MSG, example_group: method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_line_after_final_let.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after the last let block.
+      #
+      # @example
+      #   # bad
+      #   let(:foo) { bar }
+      #   let(:something) { other }
+      #   it { does_something }
+      #
+      #   # good
+      #   let(:foo) { bar }
+      #   let(:something) { other }
+      #
+      #   it { does_something }
+      #
+      class EmptyLineAfterFinalLet < Base
+        extend AutoCorrector
+        include EmptyLineSeparation
+
+        MSG = 'Add an empty line after the last `%<let>s`.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group_with_body?(node)
+
+          final_let = node.body.child_nodes.reverse.find { |child| let?(child) }
+
+          return if final_let.nil?
+
+          missing_separating_line_offense(final_let) do |method|
+            format(MSG, let: method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_line_after_hook.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after hook blocks.
+      #
+      # `AllowConsecutiveOneLiners` configures whether adjacent
+      # one-line definitions are considered an offense.
+      #
+      # @example
+      #   # bad
+      #   before { do_something }
+      #   it { does_something }
+      #
+      #   # bad
+      #   after { do_something }
+      #   it { does_something }
+      #
+      #   # bad
+      #   around { |test| test.run }
+      #   it { does_something }
+      #
+      #   # good
+      #   after { do_something }
+      #
+      #   it { does_something }
+      #
+      #   # fair - it's ok to have non-separated one-liners hooks
+      #   around { |test| test.run }
+      #   after { do_something }
+      #
+      #   it { does_something }
+      #
+      # @example with AllowConsecutiveOneLiners configuration
+      #   # rubocop.yml
+      #   # RSpec/EmptyLineAfterHook:
+      #   #   AllowConsecutiveOneLiners: false
+      #
+      #   # bad
+      #   around { |test| test.run }
+      #   after { do_something }
+      #
+      #   it { does_something }
+      #
+      #   # good
+      #   around { |test| test.run }
+      #
+      #   after { do_something }
+      #
+      #   it { does_something }
+      #
+      class EmptyLineAfterHook < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include EmptyLineSeparation
+
+        MSG = 'Add an empty line after `%<hook>s`.'
+
+        def on_block(node)
+          return unless hook?(node)
+          return if cop_config['AllowConsecutiveOneLiners'] &&
+            chained_single_line_hooks?(node)
+
+          missing_separating_line_offense(node) do |method|
+            format(MSG, hook: method)
+          end
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def chained_single_line_hooks?(node)
+          next_node = node.right_sibling
+
+          hook?(next_node) && node.single_line? && next_node.single_line?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_line_after_subject.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after subject block.
+      #
+      # @example
+      #   # bad
+      #   subject(:obj) { described_class }
+      #   let(:foo) { bar }
+      #
+      #   # good
+      #   subject(:obj) { described_class }
+      #
+      #   let(:foo) { bar }
+      #
+      class EmptyLineAfterSubject < Base
+        extend AutoCorrector
+        include EmptyLineSeparation
+        include InsideExampleGroup
+
+        MSG = 'Add an empty line after `%<subject>s`.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless subject?(node)
+          return unless inside_example_group?(node)
+
+          missing_separating_line_offense(node) do |method|
+            format(MSG, subject: method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_metadata.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Avoid empty metadata hash.
+      #
+      # @example EnforcedStyle: symbol (default)
+      #   # bad
+      #   describe 'Something', {}
+      #
+      #   # good
+      #   describe 'Something'
+      class EmptyMetadata < Base
+        extend AutoCorrector
+
+        include Metadata
+        include RangeHelp
+
+        MSG = 'Avoid empty metadata hash.'
+
+        def on_metadata(_symbols, hash)
+          return unless hash&.pairs&.empty?
+
+          add_offense(hash) do |corrector|
+            remove_empty_metadata(corrector, hash)
+          end
+        end
+
+        private
+
+        def remove_empty_metadata(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_output.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check that the `output` matcher is not called with an empty string.
+      #
+      # @example
+      #   # bad
+      #   expect { foo }.to output('').to_stdout
+      #   expect { bar }.not_to output('').to_stderr
+      #
+      #   # good
+      #   expect { foo }.not_to output.to_stdout
+      #   expect { bar }.to output.to_stderr
+      #
+      class EmptyOutput < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<runner>s` instead of matching on an empty output.'
+        RESTRICT_ON_SEND = Runners.all
+
+        # @!method matching_empty_output(node)
+        def_node_matcher :matching_empty_output, <<~PATTERN
+          (send
+            (block
+              (send nil? :expect) ...
+            )
+            #Runners.all
+            (send $(send nil? :output (str empty?)) ...)
+          )
+        PATTERN
+
+        def on_send(send_node)
+          matching_empty_output(send_node) do |node|
+            runner = send_node.method?(:to) ? 'not_to' : 'to'
+            message = format(MSG, runner: runner)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(send_node.loc.selector, runner)
+              corrector.replace(node, 'output')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/eq.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Use `eq` instead of `be ==` to compare objects.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to be == 42
+      #
+      #   # good
+      #   expect(foo).to eq 42
+      #
+      class Eq < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `eq` instead of `be ==` to compare objects.'
+        RESTRICT_ON_SEND = Runners.all
+
+        # @!method be_equals(node)
+        def_node_matcher :be_equals, <<~PATTERN
+          (send _ #Runners.all $(send (send nil? :be) :== _))
+        PATTERN
+
+        def on_send(node)
+          be_equals(node) do |matcher|
+            range = offense_range(matcher)
+            add_offense(range) do |corrector|
+              corrector.replace(range, 'eq')
+            end
+          end
+        end
+
+        private
+
+        def offense_range(matcher)
+          range_between(
+            matcher.source_range.begin_pos,
+            matcher.loc.selector.end_pos
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/example_length.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for long examples.
       #
       # A long example is usually more difficult to understand. Consider
-      # extracting out some behaviour, e.g. with a `let` block, or a helper
+      # extracting out some behavior, e.g. with a `let` block, or a helper
       # method.
       #
       # @example
@@ -25,32 +25,50 @@ module RuboCop
       #     result = service.call
       #     expect(result).to be(true)
       #   end
-      class ExampleLength < Cop
-        include RuboCop::RSpec::SpecOnly, CodeLength
-
-        EXAMPLE_BLOCKS = RuboCop::RSpec::Language::Examples::ALL
+      #
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of
+      # its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      #
+      #   it do
+      #     array = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     msg = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(            # +1
+      #       1,
+      #       2
+      #     )
+      #   end               # 6 points
+      #
+      class ExampleLength < Base
+        include CodeLength
 
-        def on_block(node)
-          method, _args, _body = *node
-          _receiver, method_name, _object = *method
-          return unless EXAMPLE_BLOCKS.include?(method_name)
+        LABEL = 'Example'
 
-          length = code_length(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example?(node)
 
-          return unless length > max_length
-          add_offense(node, :expression, message(length))
+          check_code_length(node)
         end
 
         private
 
-        def code_length(node)
-          lines = node.source.lines[1..-2]
-
-          lines.count { |line| !irrelevant_line(line) }
-        end
-
-        def message(length)
-          format('Example has too many lines. [%d/%d]', length, max_length)
+        def cop_label
+          LABEL
         end
       end
     end

data/lib/rubocop/cop/rspec/example_without_description.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for examples without a description.
+      #
+      # RSpec allows for auto-generated example descriptions when there is no
+      # description provided or the description is an empty one.
+      # It is acceptable to use `specify` without a description
+      #
+      # This cop removes empty descriptions.
+      # It also defines whether auto-generated description is allowed, based
+      # on the configured style.
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example
+      #   # always good
+      #   specify do
+      #     result = service.call
+      #     expect(result).to be(true)
+      #   end
+      #
+      # @example `EnforcedStyle: always_allow` (default)
+      #   # bad
+      #   it('') { is_expected.to be_good }
+      #   specify '' do
+      #     result = service.call
+      #     expect(result).to be(true)
+      #   end
+      #
+      #   # good
+      #   it { is_expected.to be_good }
+      #   specify do
+      #     result = service.call
+      #     expect(result).to be(true)
+      #   end
+      #
+      # @example `EnforcedStyle: single_line_only`
+      #   # bad
+      #   it('') { is_expected.to be_good }
+      #   it do
+      #     result = service.call
+      #     expect(result).to be(true)
+      #   end
+      #
+      #   # good
+      #   it { is_expected.to be_good }
+      #
+      # @example `EnforcedStyle: disallow`
+      #   # bad
+      #   it { is_expected.to be_good }
+      #   it do
+      #     result = service.call
+      #     expect(result).to be(true)
+      #   end
+      #
+      class ExampleWithoutDescription < Base
+        include ConfigurableEnforcedStyle
+
+        MSG_DEFAULT_ARGUMENT = 'Omit the argument when you want to ' \
+                               'have auto-generated description.'
+        MSG_ADD_DESCRIPTION  = 'Add a description.'
+
+        # @!method example_description(node)
+        def_node_matcher :example_description, '(send nil? _ $(str $_))'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example?(node)
+
+          check_example_without_description(node.send_node)
+
+          example_description(node.send_node) do |message_node, message|
+            return unless message.to_s.empty?
+
+            add_offense(message_node, message: MSG_DEFAULT_ARGUMENT)
+          end
+        end
+
+        private
+
+        def check_example_without_description(node)
+          return if node.arguments?
+          return unless disallow_empty_description?(node)
+          return if node.method?(:specify) && node.parent.multiline?
+
+          add_offense(node, message: MSG_ADD_DESCRIPTION)
+        end
+
+        def disallow_empty_description?(node)
+          style == :disallow ||
+            (style == :single_line_only && node.parent.multiline?)
+        end
+      end
+    end
+  end
+end