rubocop-rspec 1.7.0 → 3.0.2

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

@@ -5,6 +5,8 @@ module RuboCop
     module RSpec
       # Checks if examples are focused.
       #
+      # This cop does not support autocorrection in some cases.
+      #
       # @example
       #   # bad
       #   describe MyClass, focus: true do
@@ -19,37 +21,74 @@ module RuboCop
       #   # good
       #   describe MyClass do
       #   end
-      class Focus < Cop
-        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::Language
-
-        MSG = 'Focused spec found.'.freeze
-
-        focusable =
-          ExampleGroups::GROUPS  +
-          ExampleGroups::SKIPPED +
-          Examples::EXAMPLES     +
-          Examples::SKIPPED
-
-        focused = ExampleGroups::FOCUSED + Examples::FOCUSED
+      #
+      #   # bad
+      #   fdescribe 'test' do; end
+      #
+      #   # good
+      #   describe 'test' do; end
+      #
+      #   # bad
+      #   fdescribe 'test' do; end
+      #
+      #   # good
+      #   describe 'test' do; end
+      #
+      #   # bad
+      #   shared_examples 'test', focus: true do; end
+      #
+      #   # good
+      #   shared_examples 'test' do; end
+      #
+      #   # bad
+      #   shared_context 'test', focus: true do; end
+      #
+      #   # good
+      #   shared_context 'test' do; end
+      #
+      #   # bad (does not support autocorrection)
+      #   focus 'test' do; end
+      #
+      class Focus < Base
+        extend AutoCorrector
+        include RangeHelp
 
-        FOCUSABLE_SELECTORS = focusable.to_node_pattern
-        FOCUSING_SELECTORS  = focused.to_node_pattern
+        MSG = 'Focused spec found.'
 
-        FOCUS_SYMBOL = s(:sym, :focus)
-        FOCUS_TRUE   = s(:pair, FOCUS_SYMBOL, s(:true))
+        # @!method focusable_selector?(node)
+        def_node_matcher :focusable_selector?, <<~PATTERN
+          {
+            #ExampleGroups.regular
+            #ExampleGroups.skipped
+            #Examples.regular
+            #Examples.skipped
+            #Examples.pending
+            #SharedGroups.all
+          }
+        PATTERN
 
-        def_node_matcher :metadata, <<-PATTERN
-          {(send nil {#{FOCUSABLE_SELECTORS}} ... (hash $...))
-           (send nil {#{FOCUSABLE_SELECTORS}} $...)}
+        # @!method metadata(node)
+        def_node_matcher :metadata, <<~PATTERN
+          {(send #rspec? #focusable_selector? <$(sym :focus) ...>)
+           (send #rspec? #focusable_selector? ... (hash <$(pair (sym :focus) true) ...>))}
         PATTERN
 
-        def_node_matcher :focused_block?, <<-PATTERN
-          (send nil {#{FOCUSING_SELECTORS}} ...)
+        # @!method focused_block?(node)
+        def_node_matcher :focused_block?, <<~PATTERN
+          (send #rspec? {#ExampleGroups.focused #Examples.focused} ...)
         PATTERN
 
         def on_send(node)
+          return if node.chained? || node.each_ancestor(:def, :defs).any?
+
           focus_metadata(node) do |focus|
-            add_offense(focus, :expression)
+            add_offense(focus) do |corrector|
+              if focus.pair_type? || focus.str_type? || focus.sym_type?
+                corrector.remove(with_surrounding(focus))
+              elsif focus.send_type?
+                correct_send(corrector, focus)
+              end
+            end
           end
         end
 
@@ -58,10 +97,25 @@ module RuboCop
         def focus_metadata(node, &block)
           yield(node) if focused_block?(node)
 
-          metadata(node) do |matches|
-            matches.grep(FOCUS_SYMBOL, &block)
-            matches.grep(FOCUS_TRUE, &block)
+          metadata(node, &block)
+        end
+
+        def with_surrounding(focus)
+          range_with_space =
+            range_with_surrounding_space(focus.source_range, side: :left)
+
+          range_with_surrounding_comma(range_with_space, :left)
+        end
+
+        def correct_send(corrector, focus)
+          range = focus.loc.selector
+          unfocused = focus.method_name.to_s.sub(/^f/, '')
+          unless Examples.regular(unfocused) || ExampleGroups.regular(unfocused)
+            return
           end
+
+          corrector.replace(range,
+                            range.source.sub(focus.method_name.to_s, unfocused))
         end
       end
     end

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

@@ -10,68 +10,70 @@ module RuboCop
       # styles: "implicit", "each", and "example." All styles have
       # the same behavior.
       #
-      # @example when configuration is `EnforcedStyle: implicit`
+      # @example `EnforcedStyle: implicit` (default)
       #   # bad
       #   before(:each) do
-      #     ...
+      #     # ...
       #   end
       #
       #   # bad
       #   before(:example) do
-      #     ...
+      #     # ...
       #   end
       #
       #   # good
       #   before do
-      #     ...
+      #     # ...
       #   end
       #
-      # @example when configuration is `EnforcedStyle: each`
+      # @example `EnforcedStyle: each`
       #   # bad
       #   before(:example) do
-      #     ...
+      #     # ...
       #   end
       #
-      #   # good
+      #   # bad
       #   before do
-      #     ...
+      #     # ...
       #   end
       #
       #   # good
       #   before(:each) do
-      #     ...
+      #     # ...
       #   end
       #
-      # @example when configuration is `EnforcedStyle: example`
+      # @example `EnforcedStyle: example`
       #   # bad
       #   before(:each) do
-      #     ...
+      #     # ...
       #   end
       #
       #   # bad
       #   before do
-      #     ...
+      #     # ...
       #   end
       #
       #   # good
       #   before(:example) do
-      #     ...
+      #     # ...
       #   end
-      class HookArgument < RuboCop::Cop::Cop
-        include RuboCop::RSpec::Language,
-                RuboCop::RSpec::SpecOnly,
-                ConfigurableEnforcedStyle
-
-        IMPLICIT_MSG = 'Omit the default `%p` argument for RSpec hooks.'.freeze
-        EXPLICIT_MSG = 'Use `%p` for RSpec hooks.'.freeze
+      #
+      class HookArgument < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
 
-        HOOKS = "{#{Hooks::ALL.to_node_pattern}}".freeze
+        IMPLICIT_MSG = 'Omit the default `%<scope>p` argument for RSpec hooks.'
+        EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
 
-        def_node_matcher :scoped_hook, <<-PATTERN
-        (block $(send nil #{HOOKS} (sym ${:each :example})) ...)
+        # @!method scoped_hook(node)
+        def_node_matcher :scoped_hook, <<~PATTERN
+          ({block numblock} $(send _ #Hooks.all (sym ${:each :example})) ...)
         PATTERN
 
-        def_node_matcher :unscoped_hook, "(block $(send nil #{HOOKS}) ...)"
+        # @!method unscoped_hook(node)
+        def_node_matcher :unscoped_hook, <<~PATTERN
+          ({block numblock} $(send _ #Hooks.all) ...)
+        PATTERN
 
         def on_block(node)
           hook(node) do |method_send, scope_name|
@@ -79,33 +81,43 @@ module RuboCop
             return check_implicit(method_send) unless scope_name
 
             style_detected(scope_name)
-            add_offense(method_send, :expression, explicit_message(scope_name))
+            msg = explicit_message(scope_name)
+            add_offense(method_send, message: msg) do |corrector|
+              autocorrect(corrector, node, method_send)
+            end
           end
         end
 
-        def autocorrect(node)
-          scope = "(#{style.inspect})" unless implicit_style?
-          hook  = "#{node.method_name}#{scope}"
-
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, hook)
-          end
-        end
+        alias on_numblock on_block
 
         private
 
+        def autocorrect(corrector, _node, method_send)
+          scope = implicit_style? ? '' : "(#{style.inspect})"
+          corrector.replace(
+            LocationHelp.arguments_with_whitespace(method_send), scope
+          )
+        end
+
         def check_implicit(method_send)
           style_detected(:implicit)
           return if implicit_style?
 
-          add_offense(method_send, :selector, format(EXPLICIT_MSG, style))
+          msg = explicit_message(nil)
+          add_offense(method_send.loc.selector, message: msg) do |corrector|
+            scope = "(#{style.inspect})"
+            corrector.replace(
+              LocationHelp.arguments_with_whitespace(method_send),
+              scope
+            )
+          end
         end
 
         def explicit_message(scope)
           if implicit_style?
-            format(IMPLICIT_MSG, scope)
+            format(IMPLICIT_MSG, scope: scope)
           else
-            format(EXPLICIT_MSG, style)
+            format(EXPLICIT_MSG, scope: style)
           end
         end
 

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for before/around/after hooks that come after an example.
+      #
+      # @example
+      #   # bad
+      #   it 'checks what foo does' do
+      #     expect(foo).to be
+      #   end
+      #
+      #   before { prepare }
+      #   after { clean_up }
+      #
+      #   # good
+      #   before { prepare }
+      #   after { clean_up }
+      #
+      #   it 'checks what foo does' do
+      #     expect(foo).to be
+      #   end
+      #
+      class HooksBeforeExamples < Base
+        extend AutoCorrector
+
+        MSG = 'Move `%<hook>s` above the examples in the group.'
+
+        # @!method example_or_group?(node)
+        def_node_matcher :example_or_group?, <<~PATTERN
+          {
+            ({block numblock} {
+              (send #rspec? #ExampleGroups.all ...)
+              (send nil? #Examples.all ...)
+            } ...)
+            (send nil? #Includes.examples ...)
+          }
+        PATTERN
+
+        def on_block(node)
+          return unless example_group_with_body?(node)
+
+          check_hooks(node.body) if multiline_block?(node.body)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def multiline_block?(block)
+          block.begin_type?
+        end
+
+        def check_hooks(node)
+          first_example = find_first_example(node)
+          return unless first_example
+
+          first_example.right_siblings.each do |sibling|
+            next unless hook?(sibling)
+
+            msg = format(MSG, hook: sibling.method_name)
+            add_offense(sibling, message: msg) do |corrector|
+              autocorrect(corrector, sibling, first_example)
+            end
+          end
+        end
+
+        def find_first_example(node)
+          node.children.find { |sibling| example_or_group?(sibling) }
+        end
+
+        def autocorrect(corrector, node, first_example)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(first_example)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for equality assertions with identical expressions on both sides.
+      #
+      # @example
+      #   # bad
+      #   expect(foo.bar).to eq(foo.bar)
+      #   expect(foo.bar).to eql(foo.bar)
+      #
+      #   # good
+      #   expect(foo.bar).to eq(2)
+      #   expect(foo.bar).to eql(2)
+      #
+      class IdenticalEqualityAssertion < Base
+        MSG = 'Identical expressions on both sides of the equality ' \
+              'may indicate a flawed test.'
+        RESTRICT_ON_SEND = %i[to].freeze
+
+        # @!method equality_check?(node)
+        def_node_matcher :equality_check?, <<~PATTERN
+          (send (send nil? :expect $_) :to
+            {(send nil? {:eql :eq :be} $_)
+             (send (send nil? :be) :== $_)})
+        PATTERN
+
+        def on_send(node)
+          equality_check?(node) do |left, right|
+            add_offense(node) if left == right
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check that implicit block expectation syntax is not used.
+      #
+      # Prefer using explicit block expectations.
+      #
+      # @example
+      #   # bad
+      #   subject { -> { do_something } }
+      #   it { is_expected.to change(something).to(new_value) }
+      #
+      #   # good
+      #   it 'changes something to a new value' do
+      #     expect { do_something }.to change(something).to(new_value)
+      #   end
+      #
+      class ImplicitBlockExpectation < Base
+        MSG = 'Avoid implicit block expectations.'
+        RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
+
+        # @!method lambda?(node)
+        def_node_matcher :lambda?, <<~PATTERN
+          {
+            (send (const nil? :Proc) :new)
+            (send nil? {:proc :lambda})
+          }
+        PATTERN
+
+        # @!method lambda_subject?(node)
+        def_node_matcher :lambda_subject?, '(block #lambda? ...)'
+
+        # @!method implicit_expect(node)
+        def_node_matcher :implicit_expect, <<~PATTERN
+          $(send nil? {:is_expected :should :should_not} ...)
+        PATTERN
+
+        def on_send(node)
+          implicit_expect(node) do |implicit_expect|
+            subject = nearest_subject(implicit_expect)
+            add_offense(implicit_expect) if lambda_subject?(subject&.body)
+          end
+        end
+
+        private
+
+        def nearest_subject(node)
+          node
+            .each_ancestor(:block)
+            .lazy
+            .select { |block_node| multi_statement_example_group?(block_node) }
+            .map { |block_node| find_subject(block_node) }
+            .find(&:itself)
+        end
+
+        def multi_statement_example_group?(node)
+          example_group_with_body?(node) && node.body.begin_type?
+        end
+
+        def find_subject(block_node)
+          block_node.body.child_nodes.find { |send_node| subject?(send_node) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check that a consistent implicit expectation style is used.
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      # and supports the `--auto-gen-config` flag.
+      #
+      # @example `EnforcedStyle: is_expected` (default)
+      #   # bad
+      #   it { should be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      # @example `EnforcedStyle: should`
+      #   # bad
+      #   it { is_expected.to be_truthy }
+      #
+      #   # good
+      #   it { should be_truthy }
+      #
+      class ImplicitExpect < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%<good>s` over `%<bad>s`.'
+
+        RESTRICT_ON_SEND = Runners.all + %i[should should_not]
+
+        # @!method implicit_expect(node)
+        def_node_matcher :implicit_expect, <<~PATTERN
+          {
+            (send nil? ${:should :should_not} ...)
+            (send (send nil? $:is_expected) #Runners.all ...)
+          }
+        PATTERN
+
+        alternatives = {
+          'is_expected.to'     => 'should',
+          'is_expected.not_to' => 'should_not',
+          'is_expected.to_not' => 'should_not'
+        }
+
+        ENFORCED_REPLACEMENTS = alternatives.merge(alternatives.invert).freeze
+
+        def on_send(node) # rubocop:disable Metrics/MethodLength
+          return unless (source_range = offending_expect(node))
+
+          expectation_source = source_range.source
+
+          if expectation_source.start_with?(style.to_s)
+            correct_style_detected
+          else
+            opposite_style_detected
+
+            msg = offense_message(expectation_source)
+            add_offense(source_range, message: msg) do |corrector|
+              replacement = replacement_source(expectation_source)
+              corrector.replace(source_range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def offending_expect(node)
+          case implicit_expect(node)
+          when :is_expected
+            is_expected_range(node.loc)
+          when :should, :should_not
+            node.loc.selector
+          end
+        end
+
+        def is_expected_range(source_map) # rubocop:disable Naming/PredicateName
+          Parser::Source::Range.new(
+            source_map.expression.source_buffer,
+            source_map.expression.begin_pos,
+            source_map.selector.end_pos
+          )
+        end
+
+        def offense_message(offending_source)
+          format(
+            MSG,
+            good: replacement_source(offending_source),
+            bad:  offending_source
+          )
+        end
+
+        def replacement_source(offending_source)
+          ENFORCED_REPLACEMENTS.fetch(offending_source)
+        end
+      end
+    end
+  end
+end