rubocop-rspec 2.13.1 → 2.14.0

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module FactoryBot
+        # Use a consistent style for parentheses in factory bot calls.
+        #
+        # @example
+        #
+        #   # bad
+        #   create :user
+        #   build(:user)
+        #   create(:login)
+        #   create :login
+        #
+        # @example `EnforcedStyle: require_parentheses` (default)
+        #
+        #   # good
+        #   create(:user)
+        #   create(:user)
+        #   create(:login)
+        #   build(:login)
+        #
+        # @example `EnforcedStyle: omit_parentheses`
+        #
+        #   # good
+        #   create :user
+        #   build :user
+        #   create :login
+        #   create :login
+        #
+        class ConsistentParenthesesStyle < Base
+          extend AutoCorrector
+          include ConfigurableEnforcedStyle
+          include RuboCop::RSpec::FactoryBot::Language
+          include RuboCop::Cop::Util
+
+          def self.autocorrect_incompatible_with
+            [Style::MethodCallWithArgsParentheses]
+          end
+
+          MSG_REQUIRE_PARENS = 'Prefer method call with parentheses'
+          MSG_OMIT_PARENS = 'Prefer method call without parentheses'
+
+          FACTORY_CALLS = RuboCop::RSpec::FactoryBot::Language::METHODS
+
+          # @!method factory_call(node)
+          def_node_matcher :factory_call, <<-PATTERN
+              (send
+                ${#factory_bot? nil?} %FACTORY_CALLS
+              $...)
+          PATTERN
+
+          def on_send(node)
+            return if nested_call?(node) # prevent from nested matching
+
+            factory_call(node) do
+              if node.parenthesized?
+                process_with_parentheses(node)
+              else
+                process_without_parentheses(node)
+              end
+            end
+          end
+
+          def process_with_parentheses(node)
+            return unless style == :omit_parentheses
+
+            add_offense(node.loc.selector,
+                        message: MSG_OMIT_PARENS) do |corrector|
+              remove_parentheses(corrector, node)
+            end
+          end
+
+          def process_without_parentheses(node)
+            return unless style == :require_parentheses
+
+            add_offense(node.loc.selector,
+                        message: MSG_REQUIRE_PARENS) do |corrector|
+              add_parentheses(node, corrector)
+            end
+          end
+
+          def nested_call?(node)
+            node.parent&.send_type?
+          end
+
+          private
+
+          def remove_parentheses(corrector, node)
+            corrector.replace(node.location.begin, ' ')
+            corrector.remove(node.location.end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -238,8 +238,8 @@ module RuboCop
               indent = ' ' * node.body.loc.column
               indent_end = ' ' * node.parent.loc.column
               " do #{node.arguments.source}\n" \
-              "#{indent}#{node.body.source}\n" \
-              "#{indent_end}end"
+                "#{indent}#{node.body.source}\n" \
+                "#{indent_end}end"
             end
 
             def format_singleline_block(node)

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,18 +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 includes_skip_example?(node)
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        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 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)