rubocop-rspec 1.41.0 → 1.44.0

data/lib/rubocop/cop/rspec/capybara/feature_methods.rb

@@ -40,7 +40,9 @@ module RuboCop
         #       # ...
         #     end
         #   end
-        class FeatureMethods < Cop
+        class FeatureMethods < Base
+          extend AutoCorrector
+
           MSG = 'Use `%<replacement>s` instead of `%<method>s`.'
 
           # https://git.io/v7Kwr
@@ -53,15 +55,18 @@ module RuboCop
             feature:    :describe
           }.freeze
 
+          def_node_matcher :capybara_speak,
+                           SelectorSet.new(MAP.keys).node_pattern_union
+
           def_node_matcher :spec?, <<-PATTERN
             (block
-              (send #{RSPEC} {:describe :feature} ...)
+              (send #rspec? {:describe :feature} ...)
             ...)
           PATTERN
 
           def_node_matcher :feature_method, <<-PATTERN
             (block
-              $(send #{RSPEC} ${#{MAP.keys.map(&:inspect).join(' ')}} ...)
+              $(send #rspec? $#capybara_speak ...)
             ...)
           PATTERN
 
@@ -71,18 +76,15 @@ module RuboCop
             feature_method(node) do |send_node, match|
               next if enabled?(match)
 
-              add_offense(
-                send_node,
-                location: :selector,
-                message: format(MSG, method: match, replacement: MAP[match])
-              )
+              add_offense(send_node.loc.selector) do |corrector|
+                corrector.replace(send_node.loc.selector, MAP[match].to_s)
+              end
             end
           end
 
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.selector, MAP[node.method_name].to_s)
-            end
+          def message(range)
+            name = range.source.to_sym
+            format(MSG, method: name, replacement: MAP[name])
           end
 
           private

data/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb

@@ -26,7 +26,7 @@ module RuboCop
         #   expect(page).to have_css('.foo', visible: :all)
         #   expect(page).to have_link('my link', visible: :hidden)
         #
-        class VisibilityMatcher < Cop
+        class VisibilityMatcher < Base
           MSG_FALSE = 'Use `:all` or `:hidden` instead of `false`.'
           MSG_TRUE = 'Use `:visible` instead of `true`.'
           CAPYBARA_MATCHER_METHODS = %i[

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

@@ -23,22 +23,20 @@ module RuboCop
       #   describe '.foo_bar' do
       #     # ...
       #   end
-      class ContextMethod < Cop
+      class ContextMethod < Base
+        extend AutoCorrector
+
         MSG = 'Use `describe` for testing methods.'
 
         def_node_matcher :context_method, <<-PATTERN
-          (block (send #{RSPEC} :context $(str #method_name?) ...) ...)
+          (block (send #rspec? :context $(str #method_name?) ...) ...)
         PATTERN
 
         def on_block(node)
           context_method(node) do |context|
-            add_offense(context)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.parent.loc.selector, 'describe')
+            add_offense(context) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'describe')
+            end
           end
         end
 

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

@@ -34,11 +34,11 @@ module RuboCop
       #   context 'when the display name is not present' do
       #     # ...
       #   end
-      class ContextWording < Cop
+      class ContextWording < Base
         MSG = 'Start context description with %<prefixes>s.'
 
         def_node_matcher :context_wording, <<-PATTERN
-          (block (send #{RSPEC} { :context :shared_context } $(str #bad_prefix?) ...) ...)
+          (block (send #rspec? { :context :shared_context } $(str #bad_prefix?) ...) ...)
         PATTERN
 
         def on_block(node)
@@ -51,7 +51,7 @@ module RuboCop
         private
 
         def bad_prefix?(description)
-          !prefixes.include?(description.split.first)
+          !prefixes.include?(description.split(/\b/).first)
         end
 
         def joined_prefixes

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

@@ -3,72 +3,8 @@
 module RuboCop
   module Cop
     module RSpec
-      # @abstract parent class to RSpec cops
-      #
-      # The criteria for whether rubocop-rspec analyzes a certain ruby file
-      # is configured via `AllCops/RSpec`. For example, if you want to
-      # customize your project to scan all files within a `test/` directory
-      # then you could add this to your configuration:
-      #
-      # @example configuring analyzed paths
-      #   # .rubocop.yml
-      #   # AllCops:
-      #   #   RSpec:
-      #   #     Patterns:
-      #   #     - '_test.rb$'
-      #   #     - '(?:^|/)test/'
-      class Cop < ::RuboCop::Cop::Cop
-        include RuboCop::RSpec::Language
-        include RuboCop::RSpec::Language::NodePattern
-
-        DEFAULT_CONFIGURATION =
-          RuboCop::RSpec::CONFIG.fetch('AllCops').fetch('RSpec')
-
-        DEFAULT_PATTERN_RE = Regexp.union(
-          DEFAULT_CONFIGURATION.fetch('Patterns')
-                               .map(&Regexp.public_method(:new))
-        )
-
-        # Invoke the original inherited hook so our cops are recognized
-        def self.inherited(subclass)
-          RuboCop::Cop::Cop.inherited(subclass)
-        end
-
-        def relevant_file?(file)
-          relevant_rubocop_rspec_file?(file) && super
-        end
-
-        private
-
-        def relevant_rubocop_rspec_file?(file)
-          rspec_pattern =~ file
-        end
-
-        def rspec_pattern
-          if rspec_pattern_config?
-            Regexp.union(rspec_pattern_config.map(&Regexp.public_method(:new)))
-          else
-            DEFAULT_PATTERN_RE
-          end
-        end
-
-        def all_cops_config
-          config
-            .for_all_cops
-        end
-
-        def rspec_pattern_config?
-          return unless all_cops_config.key?('RSpec')
-
-          all_cops_config.fetch('RSpec').key?('Patterns')
-        end
-
-        def rspec_pattern_config
-          all_cops_config
-            .fetch('RSpec', DEFAULT_CONFIGURATION)
-            .fetch('Patterns')
-        end
-      end
+      # @deprecated Use ::RuboCop::Cop::RSpec::Base instead
+      Cop = Base
     end
   end
 end

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

@@ -3,7 +3,20 @@
 module RuboCop
   module Cop
     module RSpec
-      # Check that the first argument to the top level describe is a constant.
+      # Check that the first argument to the top-level describe is a constant.
+      #
+      # It can be configured to ignore strings when certain metadata is passed.
+      #
+      # Ignores Rails and Aruba `type` metadata by default.
+      #
+      # @example `IgnoredMetadata` configuration
+      #
+      #   # .rubocop.yml
+      #   # RSpec/DescribeClass:
+      #   #   IgnoredMetadata:
+      #   #     type:
+      #   #       - request
+      #   #       - controller
       #
       # @example
       #   # bad
@@ -21,50 +34,47 @@ module RuboCop
       #
       #   describe "A feature example", type: :feature do
       #   end
-      class DescribeClass < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      class DescribeClass < Base
+        include RuboCop::RSpec::TopLevelGroup
 
         MSG = 'The first argument to describe should be '\
               'the class or module being tested.'
 
-        def_node_matcher :valid_describe?, <<-PATTERN
-          {
-            (send #{RSPEC} :describe const ...)
-            (send #{RSPEC} :describe)
-          }
+        def_node_matcher :example_group_with_ignored_metadata?, <<~PATTERN
+          (send #rspec? :describe ... (hash <#ignored_metadata? ...>))
         PATTERN
 
-        def_node_matcher :describe_with_rails_metadata?, <<-PATTERN
-          (send #{RSPEC} :describe !const ...
-            (hash <#rails_metadata? ...>)
-          )
+        def_node_matcher :not_a_const_described, <<~PATTERN
+          (send #rspec? :describe $[!const !#string_constant?] ...)
         PATTERN
 
-        def_node_matcher :rails_metadata?, <<-PATTERN
-          (pair
-            (sym :type)
-            (sym {
-                   :channel :controller :helper :job :mailer :model :request
-                   :routing :view :feature :system :mailbox
-                 }
-            )
-          )
+        def_node_matcher :sym_pair, <<~PATTERN
+          (pair $sym $sym)
         PATTERN
 
-        def on_top_level_describe(node, (described_value, _))
-          return if shared_group?(root_node)
-          return if valid_describe?(node)
-          return if describe_with_rails_metadata?(node)
-          return if string_constant_describe?(described_value)
+        def on_top_level_group(node)
+          return if example_group_with_ignored_metadata?(node.send_node)
 
-          add_offense(described_value)
+          not_a_const_described(node.send_node) do |described|
+            add_offense(described)
+          end
         end
 
         private
 
-        def string_constant_describe?(described_value)
-          described_value.str_type? &&
-            described_value.value =~ /^((::)?[A-Z]\w*)+$/
+        def ignored_metadata?(node)
+          sym_pair(node) do |key, value|
+            ignored_metadata[key.value.to_s].to_a.include?(value.value.to_s)
+          end
+        end
+
+        def string_constant?(described)
+          described.str_type? &&
+            described.value.match?(/^(?:(?:::)?[A-Z]\w*)+$/)
+        end
+
+        def ignored_metadata
+          cop_config['IgnoredMetadata'] || {}
         end
       end
     end

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

@@ -16,17 +16,25 @@ module RuboCop
       #
       #   describe MyClass, '.my_class_method' do
       #   end
-      class DescribeMethod < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      class DescribeMethod < Base
+        include RuboCop::RSpec::TopLevelGroup
 
         MSG = 'The second argument to describe should be the method '\
               "being tested. '#instance' or '.class'."
 
-        def on_top_level_describe(_node, (_, second_arg))
-          return unless second_arg&.str_type?
-          return if second_arg.str_content.start_with?('#', '.')
+        def_node_matcher :second_argument, <<~PATTERN
+          (block
+            (send #rspec? :describe _first_argument $(str _) ...) ...
+          )
+        PATTERN
 
-          add_offense(second_arg)
+        def on_top_level_group(node)
+          second_argument = second_argument(node)
+
+          return unless second_argument
+          return if second_argument.str_content.start_with?('#', '.')
+
+          add_offense(second_argument)
         end
       end
     end

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

@@ -17,11 +17,11 @@ module RuboCop
       #   end
       #
       # @see https://github.com/rspec/rspec-core/issues/1610
-      class DescribeSymbol < Cop
+      class DescribeSymbol < Base
         MSG = 'Avoid describing symbols.'
 
         def_node_matcher :describe_symbol?, <<-PATTERN
-          (send #{RSPEC} :describe $sym ...)
+          (send #rspec? :describe $sym ...)
         PATTERN
 
         def on_send(node)

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

@@ -54,7 +54,8 @@ module RuboCop
       #     end
       #   end
       #
-      class DescribedClass < Cop
+      class DescribedClass < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         DESCRIBED_CLASS = 'described_class'
@@ -85,22 +86,24 @@ module RuboCop
           return unless body
 
           find_usage(body) do |match|
-            add_offense(match, message: message(match.const_name))
+            msg = message(match.const_name)
+            add_offense(match, message: msg) do |corrector|
+              autocorrect(corrector, match)
+            end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, match)
           replacement = if style == :described_class
                           DESCRIBED_CLASS
                         else
                           @described_class.const_name
                         end
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
-          end
-        end
 
-        private
+          corrector.replace(match, replacement)
+        end
 
         def find_usage(node, &block)
           yield(node) if offensive?(node)
@@ -139,7 +142,7 @@ module RuboCop
           if style == :described_class
             offensive_described_class?(node)
           else
-            node.send_type? && node.method_name == :described_class
+            node.send_type? && node.method?(:described_class)
           end
         end
 

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

@@ -19,7 +19,7 @@ module RuboCop
       #   end
       #
       # @see https://github.com/rubocop-hq/rubocop-rspec/issues/735
-      class DescribedClassModuleWrapping < Cop
+      class DescribedClassModuleWrapping < Base
         MSG = 'Avoid opening modules and defining specs within them.'
 
         def_node_search :find_rspec_blocks,

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

@@ -41,7 +41,8 @@ module RuboCop
       #   describe 'display name presence' do
       #     # ...
       #   end
-      class Dialect < Cop
+      class Dialect < Base
+        extend AutoCorrector
         include MethodPreference
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
@@ -52,24 +53,16 @@ module RuboCop
           return unless rspec_method?(node)
           return unless preferred_methods[node.method_name]
 
-          add_offense(node)
-        end
+          msg = format(MSG, prefer: preferred_method(node.method_name),
+                            current: node.method_name)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: msg) do |corrector|
             current = node.loc.selector
             preferred = preferred_method(current.source)
 
             corrector.replace(current, preferred)
           end
         end
-
-        private
-
-        def message(node)
-          format(MSG, prefer: preferred_method(node.method_name),
-                      current: node.method_name)
-        end
       end
     end
   end

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

@@ -33,6 +33,11 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
+      #   describe Bacon do
+      #     pending 'will add tests later'
+      #   end
+      #
       # @example configuration
       #
       #   # .rubocop.yml
@@ -57,24 +62,137 @@ module RuboCop
       #     end
       #   end
       #
-      class EmptyExampleGroup < Cop
+      class EmptyExampleGroup < Base
         MSG = 'Empty example group detected.'
 
-        def_node_search :contains_example?, <<-PATTERN
+        # @!method example_group_body(node)
+        #   Match example group blocks and yield their body
+        #
+        #   @example source that matches
+        #     describe 'example group' do
+        #       it { is_expected.to be }
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] example group body
+        def_node_matcher :example_group_body, <<~PATTERN
+          (block #{ExampleGroups::ALL.send_pattern} args $_)
+        PATTERN
+
+        # @!method example_or_group_or_include?(node)
+        #   Match examples, example groups and includes
+        #
+        #   @example source that matches
+        #     it { is_expected.to fly }
+        #     describe('non-empty example groups too') { }
+        #     it_behaves_like 'an animal'
+        #     it_behaves_like('a cat') { let(:food) { 'milk' } }
+        #     it_has_root_access
+        #     skip
+        #     it 'will be implemented later'
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :example_or_group_or_include?, <<~PATTERN
+          {
+            #{Examples::ALL.send_pattern}
+            #{Examples::ALL.block_pattern}
+            #{ExampleGroups::ALL.block_pattern}
+            #{Includes::ALL.send_pattern}
+            #{Includes::ALL.block_pattern}
+            (send nil? #custom_include? ...)
+          }
+        PATTERN
+
+        # @!method examples_inside_block?(node)
+        #   Match examples defined inside a block which is not a hook
+        #
+        #   @example source that matches
+        #     %w(r g b).each do |color|
+        #       it { is_expected.to have_color(color) }
+        #     end
+        #
+        #   @example source that does not match
+        #     before do
+        #       it { is_expected.to fall_into_oblivion }
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples_inside_block?, <<~PATTERN
+          (block !#{Hooks::ALL.send_pattern} _ #examples?)
+        PATTERN
+
+        # @!method examples_directly_or_in_block?(node)
+        #   Match examples or examples inside blocks
+        #
+        #   @example source that matches
+        #     it { expect(drink).to be_cold }
+        #     context('when winter') { it { expect(drink).to be_hot } }
+        #     (1..5).each { |divisor| it { is_expected.to divide_by(divisor) } }
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples_directly_or_in_block?, <<~PATTERN
           {
-            #{(Examples::ALL + Includes::ALL).send_pattern}
-            (send _ #custom_include? ...)
+            #example_or_group_or_include?
+            #examples_inside_block?
+          }
+        PATTERN
+
+        # @!method examples?(node)
+        #   Matches examples defined in scopes where they could run
+        #
+        #   @example source that matches
+        #     it { expect(myself).to be_run }
+        #     describe { it { i_run_as_well } }
+        #
+        #   @example source that does not match
+        #     before { it { whatever here wont run anyway } }
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples?, <<~PATTERN
+          {
+            #examples_directly_or_in_block?
+            (begin <#examples_directly_or_in_block? ...>)
           }
         PATTERN
 
         def on_block(node)
-          return unless example_group?(node) && !contains_example?(node)
+          return if node.each_ancestor(:def, :defs).any?
+          return if node.each_ancestor(:block).any? { |block| example?(block) }
 
-          add_offense(node.send_node)
+          example_group_body(node) do |body|
+            add_offense(node.send_node) if offensive?(body)
+          end
         end
 
         private
 
+        def offensive?(body)
+          return true unless body
+          return false if conditionals_with_examples?(body)
+
+          if body.if_type?
+            !examples_in_branches?(body)
+          else
+            !examples?(body)
+          end
+        end
+
+        def conditionals_with_examples?(body)
+          return unless body.begin_type?
+
+          body.each_descendant(:if).any? do |if_node|
+            examples_in_branches?(if_node)
+          end
+        end
+
+        def examples_in_branches?(if_node)
+          if_node.branches.any? { |branch| examples?(branch) }
+        end
+
         def custom_include?(method_name)
           custom_include_methods.include?(method_name)
         end