rubocop-rspec 2.13.2 → 2.14.0

data/CODE_OF_CONDUCT.md

@@ -9,9 +9,9 @@ to the RuboCop community. It applies to all "collaborative spaces", which are
 defined as community communications channels (such as mailing lists, submitted
 patches, commit comments, etc.).
 
-* Participants will be tolerant of opposing views.
-* Participants must ensure that their language and actions are free of personal
+- Participants will be tolerant of opposing views.
+- Participants must ensure that their language and actions are free of personal
   attacks and disparaging personal remarks.
-* When interpreting the words and actions of others, participants should always
+- When interpreting the words and actions of others, participants should always
   assume good intentions.
-* Behaviour which can be reasonably considered harassment will not be tolerated.
+- Behaviour which can be reasonably considered harassment will not be tolerated.

data/MIT-LICENSE.md

@@ -1,5 +1,4 @@
-The MIT License (MIT)
-=====================
+# The MIT License (MIT)
 
 Copyright (c) 2014 Ian MacLeod <ian@nevir.net>
 

data/config/default.yml

@@ -194,7 +194,7 @@ RSpec/ChangeByZero:
   Description: Prefer negated matchers over `to change.by(0)`.
   Enabled: pending
   VersionAdded: '2.11'
-  VersionChanged: '2.13'
+  VersionChanged: '2.14'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ChangeByZero
   NegatedMatcher: ~
 
@@ -383,8 +383,10 @@ RSpec/ExampleWording:
     have: has
     HAVE: HAS
   IgnoredWords: []
+  DisallowedExamples:
+    - works
   VersionAdded: '1.0'
-  VersionChanged: '1.2'
+  VersionChanged: '2.13'
   StyleGuide: https://rspec.rubystyle.guide/#should-in-example-docstrings
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWording
 
@@ -492,8 +494,9 @@ RSpec/ImplicitSubject:
     - single_line_only
     - single_statement_only
     - disallow
+    - require_implicit
   VersionAdded: '1.29'
-  VersionChanged: '1.30'
+  VersionChanged: '2.13'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitSubject
 
 RSpec/InstanceSpy:
@@ -640,7 +643,11 @@ RSpec/NoExpectationExample:
   Enabled: pending
   Safe: false
   VersionAdded: '2.13'
+  VersionChanged: '2.14'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NoExpectationExample
+  AllowedPatterns:
+    - "^expect_"
+    - "^assert_"
 
 RSpec/NotToNot:
   Description: Checks for consistent method usage for negating expectations.
@@ -763,6 +770,12 @@ RSpec/SingleArgumentMessageChain:
   VersionChanged: '1.10'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SingleArgumentMessageChain
 
+RSpec/SortMetadata:
+  Description: Sort RSpec metadata alphabetically.
+  Enabled: pending
+  VersionAdded: '2.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SortMetadata
+
 RSpec/StubbedMock:
   Description: Checks that message expectations do not have a configured response.
   Enabled: true
@@ -807,7 +820,6 @@ RSpec/VariableName:
     - snake_case
     - camelCase
   AllowedPatterns: []
-  IgnoredPatterns: []
   VersionAdded: '1.40'
   VersionChanged: '2.13'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VariableName
@@ -866,6 +878,22 @@ RSpec/Capybara/FeatureMethods:
   VersionChanged: '2.0'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/FeatureMethods
 
+RSpec/Capybara/NegationMatcher:
+  Description: Enforces use of `have_no_*` or `not_to` for negated expectations.
+  Enabled: pending
+  VersionAdded: '2.14'
+  EnforcedStyle: not_to
+  SupportedStyles:
+    - have_no
+    - not_to
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/NegationMatcher
+
+RSpec/Capybara/SpecificActions:
+  Description: Checks for there is a more specific actions offered by Capybara.
+  Enabled: pending
+  VersionAdded: '2.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/SpecificActions
+
 RSpec/Capybara/SpecificFinders:
   Description: Checks if there is a more specific finder offered by Capybara.
   Enabled: pending
@@ -901,6 +929,16 @@ RSpec/FactoryBot/AttributeDefinedStatically:
   VersionChanged: '2.0'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/AttributeDefinedStatically
 
+RSpec/FactoryBot/ConsistentParenthesesStyle:
+  Description: Use a consistent style for parentheses in factory bot calls.
+  Enabled: pending
+  EnforcedStyle: require_parentheses
+  SupportedStyles:
+    - require_parentheses
+    - omit_parentheses
+  VersionAdded: '2.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/ConsistentParenthesesStyle
+
 RSpec/FactoryBot/CreateList:
   Description: Checks for create_list usage.
   Enabled: true
@@ -954,6 +992,29 @@ RSpec/Rails/HaveHttpStatus:
   VersionAdded: '2.12'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/HaveHttpStatus
 
+RSpec/Rails/InferredSpecType:
+  Description: Identifies redundant spec type.
+  Enabled: pending
+  Safe: false
+  VersionAdded: '2.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/InferredSpecType
+  Inferences:
+    channels: channel
+    controllers: controller
+    features: feature
+    generator: generator
+    helpers: helper
+    jobs: job
+    mailboxes: mailbox
+    mailers: mailer
+    models: model
+    requests: request
+    integration: request
+    api: request
+    routing: routing
+    system: system
+    views: view
+
 RSpec/Rails/HttpStatus:
   Description: Enforces use of symbolic or numeric value to describe HTTP status.
   Enabled: true

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Capybara
+        # Enforces use of `have_no_*` or `not_to` for negated expectations.
+        #
+        # @example EnforcedStyle: not_to (default)
+        #   # bad
+        #   expect(page).to have_no_selector
+        #   expect(page).to have_no_css('a')
+        #
+        #   # good
+        #   expect(page).not_to have_selector
+        #   expect(page).not_to have_css('a')
+        #
+        # @example EnforcedStyle: have_no
+        #   # bad
+        #   expect(page).not_to have_selector
+        #   expect(page).not_to have_css('a')
+        #
+        #   # good
+        #   expect(page).to have_no_selector
+        #   expect(page).to have_no_css('a')
+        #
+        class NegationMatcher < Base
+          extend AutoCorrector
+          include ConfigurableEnforcedStyle
+
+          MSG = 'Use `expect(...).%<runner>s %<matcher>s`.'
+          CAPYBARA_MATCHERS = %w[
+            selector css xpath text title current_path link button
+            field checked_field unchecked_field select table
+            sibling ancestor
+          ].freeze
+          POSITIVE_MATCHERS =
+            Set.new(CAPYBARA_MATCHERS) { |element| :"have_#{element}" }.freeze
+          NEGATIVE_MATCHERS =
+            Set.new(CAPYBARA_MATCHERS) { |element| :"have_no_#{element}" }
+              .freeze
+          RESTRICT_ON_SEND = (POSITIVE_MATCHERS + NEGATIVE_MATCHERS).freeze
+
+          # @!method not_to?(node)
+          def_node_matcher :not_to?, <<~PATTERN
+            (send ... :not_to
+              (send nil? %POSITIVE_MATCHERS ...))
+          PATTERN
+
+          # @!method have_no?(node)
+          def_node_matcher :have_no?, <<~PATTERN
+            (send ... :to
+              (send nil? %NEGATIVE_MATCHERS ...))
+          PATTERN
+
+          def on_send(node)
+            return unless offense?(node.parent)
+
+            matcher = node.method_name.to_s
+            add_offense(offense_range(node),
+                        message: message(matcher)) do |corrector|
+              corrector.replace(node.parent.loc.selector, replaced_runner)
+              corrector.replace(node.loc.selector,
+                                replaced_matcher(matcher))
+            end
+          end
+
+          private
+
+          def offense?(node)
+            (style == :have_no && not_to?(node)) ||
+              (style == :not_to && have_no?(node))
+          end
+
+          def offense_range(node)
+            node.parent.loc.selector.with(end_pos: node.loc.selector.end_pos)
+          end
+
+          def message(matcher)
+            format(MSG,
+                   runner: replaced_runner,
+                   matcher: replaced_matcher(matcher))
+          end
+
+          def replaced_runner
+            case style
+            when :have_no
+              'to'
+            when :not_to
+              'not_to'
+            end
+          end
+
+          def replaced_matcher(matcher)
+            case style
+            when :have_no
+              matcher.sub('have_', 'have_no_')
+            when :not_to
+              matcher.sub('have_no_', 'have_')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Capybara
+        # Checks for there is a more specific actions offered by Capybara.
+        #
+        # @example
+        #
+        #   # bad
+        #   find('a').click
+        #   find('button.cls').click
+        #   find('a', exact_text: 'foo').click
+        #   find('div button').click
+        #
+        #   # good
+        #   click_link
+        #   click_button(class: 'cls')
+        #   click_link(exact_text: 'foo')
+        #   find('div').click_button
+        #
+        class SpecificActions < Base
+          MSG = "Prefer `%<good_action>s` over `find('%<selector>s').click`."
+          RESTRICT_ON_SEND = %i[click].freeze
+          SPECIFIC_ACTION = {
+            'button' => 'button',
+            'a' => 'link'
+          }.freeze
+
+          # @!method click_on_selector(node)
+          def_node_matcher :click_on_selector, <<-PATTERN
+            (send _ :find (str $_) ...)
+          PATTERN
+
+          def on_send(node)
+            click_on_selector(node.receiver) do |arg|
+              next unless supported_selector?(arg)
+              # Always check the last selector in the case of multiple selectors
+              # separated by whitespace.
+              # because the `.click` is executed on the element to
+              # which the last selector points.
+              next unless (selector = last_selector(arg))
+              next unless (action = specific_action(selector))
+              next unless CapybaraHelp.specific_option?(node.receiver, arg,
+                                                        action)
+              next unless CapybaraHelp.specific_pseudo_classes?(arg)
+
+              range = offense_range(node, node.receiver)
+              add_offense(range, message: message(action, selector))
+            end
+          end
+
+          private
+
+          def specific_action(selector)
+            SPECIFIC_ACTION[last_selector(selector)]
+          end
+
+          def supported_selector?(selector)
+            !selector.match?(/[>,+~]/)
+          end
+
+          def last_selector(arg)
+            arg.split.last[/^\w+/, 0]
+          end
+
+          def offense_range(node, receiver)
+            receiver.loc.selector.with(end_pos: node.loc.expression.end_pos)
+          end
+
+          def message(action, selector)
+            format(MSG,
+                   good_action: good_action(action),
+                   selector: selector)
+          end
+
+          def good_action(action)
+            "click_#{action}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,9 @@ module RuboCop
         #   expect(page).to have_select
         #   expect(page).to have_field('foo')
         #
-        class SpecificMatcher < Base # rubocop:disable Metrics/ClassLength
+        class SpecificMatcher < Base
+          include CapybaraHelp
+
           MSG = 'Prefer `%<good_matcher>s` over `%<bad_matcher>s`.'
           RESTRICT_ON_SEND = %i[have_selector have_no_selector have_css
                                 have_no_css].freeze
@@ -37,51 +39,18 @@ module RuboCop
             'select' => 'select',
             'input' => 'field'
           }.freeze
-          SPECIFIC_MATCHER_OPTIONS = {
-            'button' => (
-              CssSelector::COMMON_OPTIONS + %w[disabled name value title type]
-            ).freeze,
-            'link' => (
-              CssSelector::COMMON_OPTIONS + %w[href alt title download]
-            ).freeze,
-            'table' => (
-              CssSelector::COMMON_OPTIONS + %w[
-                caption with_cols cols with_rows rows
-              ]
-            ).freeze,
-            'select' => (
-              CssSelector::COMMON_OPTIONS + %w[
-                disabled name placeholder options enabled_options
-                disabled_options selected with_selected multiple with_options
-              ]
-            ).freeze,
-            'field' => (
-              CssSelector::COMMON_OPTIONS + %w[
-                checked unchecked disabled valid name placeholder
-                validation_message readonly with type multiple
-              ]
-            ).freeze
-          }.freeze
-          SPECIFIC_MATCHER_PSEUDO_CLASSES = %w[
-            not() disabled enabled checked unchecked
-          ].freeze
 
           # @!method first_argument(node)
           def_node_matcher :first_argument, <<-PATTERN
             (send nil? _ (str $_) ... )
           PATTERN
 
-          # @!method option?(node)
-          def_node_search :option?, <<-PATTERN
-            (pair (sym %) _)
-          PATTERN
-
           def on_send(node)
             first_argument(node) do |arg|
               next unless (matcher = specific_matcher(arg))
               next if CssSelector.multiple_selectors?(arg)
-              next unless specific_matcher_option?(node, arg, matcher)
-              next unless specific_matcher_pseudo_classes?(arg)
+              next unless specific_option?(node, arg, matcher)
+              next unless specific_pseudo_classes?(arg)
 
               add_offense(node, message: message(node, matcher))
             end
@@ -94,52 +63,6 @@ module RuboCop
             SPECIFIC_MATCHER[splitted_arg]
           end
 
-          def specific_matcher_option?(node, arg, matcher)
-            attrs = CssSelector.attributes(arg).keys
-            return true if attrs.empty?
-            return false unless replaceable_matcher?(node, matcher, attrs)
-
-            attrs.all? do |attr|
-              SPECIFIC_MATCHER_OPTIONS.fetch(matcher, []).include?(attr)
-            end
-          end
-
-          def specific_matcher_pseudo_classes?(arg)
-            CssSelector.pseudo_classes(arg).all? do |pseudo_class|
-              replaceable_pseudo_class?(pseudo_class, arg)
-            end
-          end
-
-          def replaceable_pseudo_class?(pseudo_class, arg)
-            unless SPECIFIC_MATCHER_PSEUDO_CLASSES.include?(pseudo_class)
-              return false
-            end
-
-            case pseudo_class
-            when 'not()' then replaceable_pseudo_class_not?(arg)
-            else true
-            end
-          end
-
-          def replaceable_pseudo_class_not?(arg)
-            arg.scan(/not\(.*?\)/).all? do |not_arg|
-              CssSelector.attributes(not_arg).values.all? do |v|
-                v.is_a?(TrueClass) || v.is_a?(FalseClass)
-              end
-            end
-          end
-
-          def replaceable_matcher?(node, matcher, attrs)
-            case matcher
-            when 'link' then replaceable_to_have_link?(node, attrs)
-            else true
-            end
-          end
-
-          def replaceable_to_have_link?(node, attrs)
-            option?(node, :href) || attrs.include?('href')
-          end
-
           def message(node, matcher)
             format(MSG,
                    good_matcher: good_matcher(node, matcher),

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

@@ -61,7 +61,7 @@ module RuboCop
         extend AutoCorrector
         MSG = 'Prefer `not_to change` over `to change.by(0)`.'
         MSG_COMPOUND = 'Prefer %<preferred>s with compound expectations ' \
-                          'over `change.by(0)`.'
+                       'over `change.by(0)`.'
         RESTRICT_ON_SEND = %i[change].freeze
 
         # @!method expect_change_with_arguments(node)

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

@@ -43,7 +43,7 @@ module RuboCop
       #   # .rubocop.yml
       #   # RSpec/ContextWording:
       #   #   AllowedPatterns:
-      #   #     - /とき$/
+      #   #     - とき$
       #
       # @example
       #   # bad
@@ -92,7 +92,9 @@ module RuboCop
         end
 
         def expect_patterns
-          inspected = allowed_patterns.map(&:inspect)
+          inspected = allowed_patterns.map do |pattern|
+            pattern.inspect.gsub(/\A"|"\z/, '/')
+          end
           return inspected.first if inspected.size == 1
 
           inspected << "or #{inspected.pop}"

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

@@ -6,12 +6,17 @@ module RuboCop
       # Checks for common mistakes in example descriptions.
       #
       # This cop will correct docstrings that begin with 'should' and 'it'.
+      # This cop will also look for insufficient examples and call them out.
       #
       # @see http://betterspecs.org/#should
       #
       # The autocorrect is experimental - use with care! It can be configured
       # with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only).
       #
+      # Use the DisallowedExamples setting to prevent unclear or insufficient
+      # descriptions. Please note that this config will not be treated as
+      # case sensitive.
+      #
       # @example
       #   # bad
       #   it 'should find nothing' do
@@ -30,11 +35,21 @@ module RuboCop
       #   it 'does things' do
       #   end
       #
+      # @example `DisallowedExamples: ['works']` (default)
+      #   # bad
+      #   it 'works' do
+      #   end
+      #
+      #   # good
+      #   it 'marks the task as done' do
+      #   end
       class ExampleWording < Base
         extend AutoCorrector
 
         MSG_SHOULD = 'Do not use should when describing your tests.'
         MSG_IT     = "Do not repeat 'it' when describing your tests."
+        MSG_INSUFFICIENT_DESCRIPTION = 'Your example description is ' \
+                                       'insufficient.'
 
         SHOULD_PREFIX = /\Ashould(?:n't)?\b/i.freeze
         IT_PREFIX     = /\Ait /i.freeze
@@ -53,12 +68,20 @@ module RuboCop
               add_wording_offense(description_node, MSG_SHOULD)
             elsif message.match?(IT_PREFIX)
               add_wording_offense(description_node, MSG_IT)
+            else
+              check_and_handle_insufficient_examples(description_node)
             end
           end
         end
 
         private
 
+        def check_and_handle_insufficient_examples(description)
+          if insufficient_examples.include?(preprocess(text(description)))
+            add_wording_offense(description, MSG_INSUFFICIENT_DESCRIPTION)
+          end
+        end
+
         def add_wording_offense(node, message)
           docstring = docstring(node)
 
@@ -113,6 +136,15 @@ module RuboCop
         def ignored_words
           cop_config.fetch('IgnoredWords', [])
         end
+
+        def insufficient_examples
+          examples = cop_config.fetch('DisallowedExamples', [])
+          examples.map! { |example| preprocess(example) }
+        end
+
+        def preprocess(message)
+          message.strip.squeeze(' ').downcase
+        end
       end
     end
   end

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)