rubocop-rspec 2.13.2 → 2.14.0

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

@@ -54,25 +54,7 @@ module RuboCop
 
           MSG = 'Use `%<method>s` from `FactoryBot::Syntax::Methods`.'
 
-          RESTRICT_ON_SEND = %i[
-            attributes_for
-            attributes_for_list
-            attributes_for_pair
-            build
-            build_list
-            build_pair
-            build_stubbed
-            build_stubbed_list
-            build_stubbed_pair
-            create
-            create_list
-            create_pair
-            generate
-            generate_list
-            null
-            null_list
-            null_pair
-          ].to_set.freeze
+          RESTRICT_ON_SEND = RuboCop::RSpec::FactoryBot::Language::METHODS
 
           def on_send(node)
             return unless factory_bot?(node.receiver)

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

@@ -42,12 +42,45 @@ module RuboCop
       #   # good
       #   it { expect(subject).to be_truthy }
       #
+      # @example `EnforcedStyle: require_implicit`
+      #   # bad
+      #   it { expect(subject).to be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      #   # bad
+      #   it do
+      #     expect(subject).to be_truthy
+      #   end
+      #
+      #   # good
+      #   it do
+      #     is_expected.to be_truthy
+      #   end
+      #
+      #   # good
+      #   it { expect(named_subject).to be_truthy }
+      #
       class ImplicitSubject < Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
 
-        MSG = "Don't use implicit subject."
-        RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
+        MSG_REQUIRE_EXPLICIT = "Don't use implicit subject."
+
+        MSG_REQUIRE_IMPLICIT = "Don't use explicit subject."
+
+        RESTRICT_ON_SEND = %i[
+          expect
+          is_expected
+          should
+          should_not
+        ].freeze
+
+        # @!method explicit_unnamed_subject?(node)
+        def_node_matcher :explicit_unnamed_subject?, <<-PATTERN
+          (send nil? :expect (send nil? :subject))
+        PATTERN
 
         # @!method implicit_subject?(node)
         def_node_matcher :implicit_subject?, <<-PATTERN
@@ -55,8 +88,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless implicit_subject?(node)
-          return if valid_usage?(node)
+          return unless invalid?(node)
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)
@@ -66,32 +98,67 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          replacement = 'expect(subject)'
           case node.method_name
+          when :expect
+            corrector.replace(node, 'is_expected')
+          when :is_expected
+            corrector.replace(node.location.selector, 'expect(subject)')
           when :should
-            replacement += '.to'
+            corrector.replace(node.location.selector, 'expect(subject).to')
           when :should_not
-            replacement += '.not_to'
+            corrector.replace(node.location.selector, 'expect(subject).not_to')
           end
-
-          corrector.replace(node.loc.selector, replacement)
         end
 
-        def valid_usage?(node)
-          example = node.ancestors.find { |parent| example?(parent) }
-          return false if example.nil?
-
-          example.method?(:its) || allowed_by_style?(example)
+        def message(_node)
+          case style
+          when :require_implicit
+            MSG_REQUIRE_IMPLICIT
+          else
+            MSG_REQUIRE_EXPLICIT
+          end
         end
 
-        def allowed_by_style?(example)
+        def invalid?(node)
           case style
+          when :require_implicit
+            explicit_unnamed_subject?(node)
+          when :disallow
+            implicit_subject_in_non_its?(node)
           when :single_line_only
-            example.single_line?
+            implicit_subject_in_non_its_and_non_single_line?(node)
           when :single_statement_only
-            !example.body.begin_type?
-          else
-            false
+            implicit_subject_in_non_its_and_non_single_statement?(node)
+          end
+        end
+
+        def implicit_subject_in_non_its?(node)
+          implicit_subject?(node) && !its?(node)
+        end
+
+        def implicit_subject_in_non_its_and_non_single_line?(node)
+          implicit_subject_in_non_its?(node) && !single_line?(node)
+        end
+
+        def implicit_subject_in_non_its_and_non_single_statement?(node)
+          implicit_subject_in_non_its?(node) && !single_statement?(node)
+        end
+
+        def its?(node)
+          example_of(node)&.method?(:its)
+        end
+
+        def single_line?(node)
+          example_of(node)&.single_line?
+        end
+
+        def single_statement?(node)
+          !example_of(node)&.body&.begin_type?
+        end
+
+        def example_of(node)
+          node.each_ancestor.find do |ancestor|
+            example?(ancestor)
           end
         end
       end

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

@@ -43,6 +43,14 @@ module RuboCop
           }
         PATTERN
 
+        # @!method include_examples?(node)
+        def_node_matcher :include_examples?, <<~PATTERN
+          {
+            #{block_pattern(':include_examples')}
+            #{send_pattern(':include_examples')}
+          }
+        PATTERN
+
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group_with_body?(node)
 
@@ -51,6 +59,10 @@ module RuboCop
 
         private
 
+        def example_group_with_include_examples?(body)
+          body.children.any? { |sibling| include_examples?(sibling) }
+        end
+
         def multiline_block?(block)
           block.begin_type?
         end
@@ -59,11 +71,13 @@ module RuboCop
           first_example = find_first_example(node)
           return unless first_example
 
+          correct = !example_group_with_include_examples?(node)
+
           first_example.right_siblings.each do |sibling|
             next unless let?(sibling)
 
             add_offense(sibling) do |corrector|
-              autocorrect(corrector, sibling, first_example)
+              autocorrect(corrector, sibling, first_example) if correct
             end
           end
         end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Help methods for capybara.
+      module CapybaraHelp
+        module_function
+
+        # @param node [RuboCop::AST::SendNode]
+        # @param locator [String]
+        # @param element [String]
+        # @return [Boolean]
+        def specific_option?(node, locator, element)
+          attrs = CssSelector.attributes(locator).keys
+          return false unless replaceable_element?(node, element, attrs)
+
+          attrs.all? do |attr|
+            CssSelector.specific_options?(element, attr)
+          end
+        end
+
+        # @param locator [String]
+        # @return [Boolean]
+        def specific_pseudo_classes?(locator)
+          CssSelector.pseudo_classes(locator).all? do |pseudo_class|
+            replaceable_pseudo_class?(pseudo_class, locator)
+          end
+        end
+
+        # @param pseudo_class [String]
+        # @param locator [String]
+        # @return [Boolean]
+        def replaceable_pseudo_class?(pseudo_class, locator)
+          return false unless CssSelector.specific_pesudo_classes?(pseudo_class)
+
+          case pseudo_class
+          when 'not()' then replaceable_pseudo_class_not?(locator)
+          else true
+          end
+        end
+
+        # @param locator [String]
+        # @return [Boolean]
+        def replaceable_pseudo_class_not?(locator)
+          locator.scan(/not\(.*?\)/).all? do |negation|
+            CssSelector.attributes(negation).values.all? do |v|
+              v.is_a?(TrueClass) || v.is_a?(FalseClass)
+            end
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @param element [String]
+        # @param attrs [Array<String>]
+        # @return [Boolean]
+        def replaceable_element?(node, element, attrs)
+          case element
+          when 'link' then replaceable_to_link?(node, attrs)
+          else true
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @param attrs [Array<String>]
+        # @return [Boolean]
+        def replaceable_to_link?(node, attrs)
+          include_option?(node, :href) || attrs.include?('href')
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @param option [Symbol]
+        # @return [Boolean]
+        def include_option?(node, option)
+          node.each_descendant(:sym).find { |opt| opt.value == option }
+        end
+      end
+    end
+  end
+end

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

@@ -10,9 +10,56 @@ module RuboCop
           id class style visible obscured exact exact_text normalize_ws match
           wait filter_set focused
         ].freeze
+        SPECIFIC_OPTIONS = {
+          'button' => (
+            COMMON_OPTIONS + %w[disabled name value title type]
+          ).freeze,
+          'link' => (
+            COMMON_OPTIONS + %w[href alt title download]
+          ).freeze,
+          'table' => (
+            COMMON_OPTIONS + %w[
+              caption with_cols cols with_rows rows
+            ]
+          ).freeze,
+          'select' => (
+            COMMON_OPTIONS + %w[
+              disabled name placeholder options enabled_options
+              disabled_options selected with_selected multiple with_options
+            ]
+          ).freeze,
+          'field' => (
+            COMMON_OPTIONS + %w[
+              checked unchecked disabled valid name placeholder
+              validation_message readonly with type multiple
+            ]
+          ).freeze
+        }.freeze
+        SPECIFIC_PSEUDO_CLASSES = %w[
+          not() disabled enabled checked unchecked
+        ].freeze
 
         module_function
 
+        # @param element [String]
+        # @param attribute [String]
+        # @return [Boolean]
+        # @example
+        #   specific_pesudo_classes?('button', 'name') # => true
+        #   specific_pesudo_classes?('link', 'invalid') # => false
+        def specific_options?(element, attribute)
+          SPECIFIC_OPTIONS.fetch(element, []).include?(attribute)
+        end
+
+        # @param pseudo_class [String]
+        # @return [Boolean]
+        # @example
+        #   specific_pesudo_classes?('disabled') # => true
+        #   specific_pesudo_classes?('first-of-type') # => false
+        def specific_pesudo_classes?(pseudo_class)
+          SPECIFIC_PSEUDO_CLASSES.include?(pseudo_class)
+        end
+
         # @param selector [String]
         # @return [Boolean]
         # @example
@@ -75,7 +122,7 @@ module RuboCop
         #   multiple_selectors?('a.cls b#id') # => true
         #   multiple_selectors?('a.cls') # => false
         def multiple_selectors?(selector)
-          selector.match?(/[ >,+]/)
+          selector.match?(/[ >,+~]/)
         end
 
         # @param value [String]

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps check offenses with variable definitions
+      module SkipOrPending
+        extend RuboCop::NodePattern::Macros
+
+        # @!method skipped_in_metadata?(node)
+        def_node_matcher :skipped_in_metadata?, <<-PATTERN
+          {
+            (send _ _ <#skip_or_pending? ...>)
+            (send _ _ ... (hash <(pair #skip_or_pending? { true str }) ...>))
+          }
+        PATTERN
+
+        # @!method skip_or_pending?(node)
+        def_node_matcher :skip_or_pending?, '{(sym :skip) (sym :pending)}'
+      end
+    end
+  end
+end

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

@@ -28,7 +28,37 @@ module RuboCop
       #     expect(a?).to be(true)
       #   end
       #
+      # This cop can be customized with an allowed expectation methods pattern
+      # with an `AllowedPatterns` option. ^expect_ and ^assert_ are allowed
+      # by default.
+      #
+      # @example `AllowedPatterns` configuration
+      #
+      #   # .rubocop.yml
+      #   # RSpec/NoExpectationExample:
+      #   #   AllowedPatterns:
+      #   #     - ^expect_
+      #   #     - ^assert_
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     not_expect_something
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect_something
+      #   end
+      #
+      #   it do
+      #     assert_something
+      #   end
+      #
       class NoExpectationExample < Base
+        include AllowedPattern
+        include SkipOrPending
+
         MSG = 'No expectation found in this example.'
 
         # @!method regular_or_focused_example?(node)
@@ -41,26 +71,29 @@ module RuboCop
           }
         PATTERN
 
-        # @!method including_any_expectation?(node)
+        # @!method includes_expectation?(node)
         # @param [RuboCop::AST::Node] node
         # @return [Boolean]
-        def_node_search(
-          :including_any_expectation?,
-          send_pattern('#Expectations.all')
-        )
+        def_node_search :includes_expectation?, <<~PATTERN
+          {
+            #{send_pattern('#Expectations.all')}
+            (send nil? `#matches_allowed_pattern?)
+          }
+        PATTERN
 
-        # @!method including_any_skip_example?(node)
+        # @!method includes_skip_example?(node)
         # @param [RuboCop::AST::Node] node
         # @return [Boolean]
-        def_node_search :including_any_skip_example?, <<~PATTERN
+        def_node_search :includes_skip_example?, <<~PATTERN
           (send nil? {:pending :skip} ...)
         PATTERN
 
         # @param [RuboCop::AST::BlockNode] node
         def on_block(node)
           return unless regular_or_focused_example?(node)
-          return if including_any_expectation?(node)
-          return if including_any_skip_example?(node)
+          return if includes_expectation?(node)
+          return if includes_skip_example?(node)
+          return if skipped_in_metadata?(node.send_node)
 
           add_offense(node)
         end

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

@@ -33,6 +33,8 @@ module RuboCop
       #   end
       #
       class Pending < Base
+        include SkipOrPending
+
         MSG = 'Pending spec found.'
 
         # @!method skippable?(node)
@@ -41,17 +43,6 @@ module RuboCop
                            {#ExampleGroups.regular #Examples.regular}
                          PATTERN
 
-        # @!method skipped_in_metadata?(node)
-        def_node_matcher :skipped_in_metadata?, <<-PATTERN
-          {
-            (send _ _ <#skip_or_pending? ...>)
-            (send _ _ ... (hash <(pair #skip_or_pending? { true str }) ...>))
-          }
-        PATTERN
-
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, '{(sym :skip) (sym :pending)}'
-
         # @!method pending_block?(node)
         def_node_matcher :pending_block?,
                          send_pattern(<<~PATTERN)

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Rails
+        # Identifies redundant spec type.
+        #
+        # After setting up rspec-rails, you will have enabled
+        # `config.infer_spec_type_from_file_location!` by default in
+        # spec/rails_helper.rb. This cop works in conjunction with this config.
+        # If you disable this config, disable this cop as well.
+        #
+        # @safety
+        #   This cop is marked as unsafe because
+        #   `config.infer_spec_type_from_file_location!` may not be enabled.
+        #
+        # @example
+        #   # bad
+        #   # spec/models/user_spec.rb
+        #   RSpec.describe User, type: :model do
+        #   end
+        #
+        #   # good
+        #   # spec/models/user_spec.rb
+        #   RSpec.describe User do
+        #   end
+        #
+        #   # good
+        #   # spec/models/user_spec.rb
+        #   RSpec.describe User, type: :common do
+        #   end
+        #
+        # @example `Inferences` configuration
+        #   # .rubocop.yml
+        #   # RSpec/InferredSpecType:
+        #   #   Inferences:
+        #   #     services: service
+        #
+        #   # bad
+        #   # spec/services/user_spec.rb
+        #   RSpec.describe User, type: :service do
+        #   end
+        #
+        #   # good
+        #   # spec/services/user_spec.rb
+        #   RSpec.describe User do
+        #   end
+        #
+        #   # good
+        #   # spec/services/user_spec.rb
+        #   RSpec.describe User, type: :common do
+        #   end
+        class InferredSpecType < Base
+          extend AutoCorrector
+
+          MSG = 'Remove redundant spec type.'
+
+          # @param [RuboCop::AST::BlockNode] node
+          def on_block(node)
+            return unless example_group?(node)
+
+            pair_node = describe_with_type(node)
+            return unless pair_node
+            return unless inferred_type?(pair_node)
+
+            removable_node = detect_removable_node(pair_node)
+            add_offense(removable_node) do |corrector|
+              autocorrect(corrector, removable_node)
+            end
+          end
+          alias on_numblock on_block
+
+          private
+
+          # @!method describe_with_type(node)
+          #   @param [RuboCop::AST::BlockNode] node
+          #   @return [RuboCop::AST::PairNode, nil]
+          def_node_matcher :describe_with_type, <<~PATTERN
+            (block
+              (send #rspec? #ExampleGroups.all
+                ...
+                (hash <$(pair (sym :type) sym) ...>)
+              )
+              ...
+            )
+          PATTERN
+
+          # @param [RuboCop::AST::Corrector] corrector
+          # @param [RuboCop::AST::Node] node
+          def autocorrect(corrector, node)
+            corrector.remove(
+              node.location.expression.with(
+                begin_pos: node.left_sibling.location.expression.end_pos
+              )
+            )
+          end
+
+          # @param [RuboCop::AST::PairNode] node
+          # @return [RuboCop::AST::Node]
+          def detect_removable_node(node)
+            if node.parent.pairs.size == 1
+              node.parent
+            else
+              node
+            end
+          end
+
+          # @return [String]
+          def file_path
+            processed_source.file_path
+          end
+
+          # @param [RuboCop::AST::PairNode] node
+          # @return [Boolean]
+          def inferred_type?(node)
+            inferred_type_from_file_path.inspect == node.value.source
+          end
+
+          # @return [Symbol, nil]
+          def inferred_type_from_file_path
+            inferences.find do |prefix, type|
+              break type.to_sym if file_path.include?("spec/#{prefix}/")
+            end
+          end
+
+          # @return [Hash]
+          def inferences
+            cop_config['Inferences'] || {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -47,7 +47,7 @@ module RuboCop
       #
       class RepeatedIncludeExample < Base
         MSG = 'Repeated include of shared_examples %<name>s ' \
-          'on line(s) %<repeat>s'
+              'on line(s) %<repeat>s'
 
         # @!method several_include_examples?(node)
         def_node_matcher :several_include_examples?, <<-PATTERN