rubocop-rspec 2.16.0 → 2.24.1

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

@@ -24,7 +24,7 @@ module RuboCop
       class ExpectActual < Base
         extend AutoCorrector
 
-        MSG = 'Provide the actual you are testing to `expect(...)`.'
+        MSG = 'Provide the actual value you are testing to `expect(...)`.'
 
         RESTRICT_ON_SEND = Runners.all
 
@@ -77,7 +77,7 @@ module RuboCop
 
         private
 
-        # This is not implement using a NodePattern because it seems
+        # This is not implemented using a NodePattern because it seems
         # to not be able to match against an explicit (nil) sexp
         def literal?(node)
           node && (simple_literal?(node) || complex_literal?(node))
@@ -93,8 +93,8 @@ module RuboCop
         end
 
         def swap(corrector, actual, expected)
-          corrector.replace(actual.source_range, expected.source)
-          corrector.replace(expected.source_range, actual.source)
+          corrector.replace(actual, expected.source)
+          corrector.replace(expected, actual.source)
         end
       end
     end

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

@@ -25,7 +25,7 @@ module RuboCop
         MSG = 'Do not use `%<expect>s` in `%<hook>s` hook'
 
         # @!method expectation(node)
-        def_node_search :expectation, send_pattern('#Expectations.all')
+        def_node_search :expectation, '(send nil? #Expectations.all ...)'
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless hook?(node)

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

@@ -4,124 +4,31 @@ module RuboCop
   module Cop
     module RSpec
       module FactoryBot
-        # Always declare attribute values as blocks.
-        #
-        # @example
-        #   # bad
-        #   kind [:active, :rejected].sample
-        #
-        #   # good
-        #   kind { [:active, :rejected].sample }
-        #
-        #   # bad
-        #   closed_at 1.day.from_now
-        #
-        #   # good
-        #   closed_at { 1.day.from_now }
-        #
-        #   # bad
-        #   count 1
-        #
-        #   # good
-        #   count { 1 }
-        #
-        class AttributeDefinedStatically < ::RuboCop::Cop::Base
-          extend AutoCorrector
-
-          MSG = 'Use a block to declare attribute values.'
-
-          # @!method value_matcher(node)
-          def_node_matcher :value_matcher, <<-PATTERN
-            (send _ !#reserved_method? $...)
-          PATTERN
-
-          # @!method factory_attributes(node)
-          def_node_matcher :factory_attributes, <<-PATTERN
-            (block (send _ #attribute_defining_method? ...) _ { (begin $...) $(send ...) } )
-          PATTERN
-
-          def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
-            attributes = factory_attributes(node) || []
-            attributes = [attributes] unless attributes.is_a?(Array) # rubocop:disable Style/ArrayCoercion, Lint/RedundantCopDisableDirective
-
-            attributes.each do |attribute|
-              next unless offensive_receiver?(attribute.receiver, node)
-              next if proc?(attribute) || association?(attribute.first_argument)
-
-              add_offense(attribute) do |corrector|
-                autocorrect(corrector, attribute)
-              end
-            end
-          end
-
-          private
-
-          def autocorrect(corrector, node)
-            if node.parenthesized?
-              autocorrect_replacing_parens(corrector, node)
-            else
-              autocorrect_without_parens(corrector, node)
-            end
-          end
-
-          def offensive_receiver?(receiver, node)
-            receiver.nil? ||
-              receiver.self_type? ||
-              receiver_matches_first_block_argument?(receiver, node)
-          end
-
-          def receiver_matches_first_block_argument?(receiver, node)
-            first_block_argument = node.arguments.first
-
-            !first_block_argument.nil? &&
-              receiver.lvar_type? &&
-              receiver.node_parts == first_block_argument.node_parts
-          end
-
-          def proc?(attribute)
-            value_matcher(attribute).to_a.all?(&:block_pass_type?)
-          end
-
-          # @!method association?(node)
-          def_node_matcher :association?, '(hash <(pair (sym :factory) _) ...>)'
-
-          def autocorrect_replacing_parens(corrector, node)
-            left_braces, right_braces = braces(node)
-
-            corrector.replace(node.location.begin, " #{left_braces}")
-            corrector.replace(node.location.end, right_braces)
-          end
-
-          def autocorrect_without_parens(corrector, node)
-            left_braces, right_braces = braces(node)
-
-            argument = node.first_argument
-            expression = argument.location.expression
-            corrector.insert_before(expression, left_braces)
-            corrector.insert_after(expression, right_braces)
-          end
-
-          def braces(node)
-            if value_hash_without_braces?(node.first_argument)
-              ['{ { ', ' } }']
-            else
-              ['{ ', ' }']
-            end
-          end
-
-          def value_hash_without_braces?(node)
-            node.hash_type? && !node.braces?
-          end
-
-          def reserved_method?(method_name)
-            RuboCop::RSpec::FactoryBot.reserved_methods.include?(method_name)
-          end
-
-          def attribute_defining_method?(method_name)
-            RuboCop::RSpec::FactoryBot.attribute_defining_methods
-              .include?(method_name)
-          end
-        end
+        # @!parse
+        #   # Always declare attribute values as blocks.
+        #   #
+        #   # @example
+        #   #   # bad
+        #   #   kind [:active, :rejected].sample
+        #   #
+        #   #   # good
+        #   #   kind { [:active, :rejected].sample }
+        #   #
+        #   #   # bad
+        #   #   closed_at 1.day.from_now
+        #   #
+        #   #   # good
+        #   #   closed_at { 1.day.from_now }
+        #   #
+        #   #   # bad
+        #   #   count 1
+        #   #
+        #   #   # good
+        #   #   count { 1 }
+        #   #
+        #   class AttributeDefinedStatically < ::RuboCop::Cop::Base; end
+        AttributeDefinedStatically =
+          ::RuboCop::Cop::FactoryBot::AttributeDefinedStatically
       end
     end
   end

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

@@ -4,113 +4,46 @@ 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
-        #
-        #   # also good
-        #   # when method name and first argument are not on same line
-        #   create(
-        #     :user
-        #   )
-        #   build(
-        #     :user,
-        #     name: 'foo'
-        #   )
-        #
-        class ConsistentParenthesesStyle < ::RuboCop::Cop::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
-
-          RESTRICT_ON_SEND = FACTORY_CALLS
-
-          # @!method factory_call(node)
-          def_node_matcher :factory_call, <<-PATTERN
-            (send
-              {#factory_bot? nil?} %FACTORY_CALLS
-              {sym str send lvar} _*
-            )
-          PATTERN
-
-          def on_send(node)
-            return if ambiguous_without_parentheses?(node)
-
-            factory_call(node) do
-              return if node.method?(:generate) && node.arguments.count > 1
-
-              if node.parenthesized?
-                process_with_parentheses(node)
-              else
-                process_without_parentheses(node)
-              end
-            end
-          end
-
-          private
-
-          def process_with_parentheses(node)
-            return unless style == :omit_parentheses
-            return unless same_line?(node, node.first_argument)
-
-            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 ambiguous_without_parentheses?(node)
-            node.parent&.send_type? ||
-              node.parent&.pair_type? ||
-              node.parent&.array_type?
-          end
-
-          def remove_parentheses(corrector, node)
-            corrector.replace(node.location.begin, ' ')
-            corrector.remove(node.location.end)
-          end
-        end
+        # @!parse
+        #   # 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
+        #   #
+        #   #   # also good
+        #   #   # when method name and first argument are not on same line
+        #   #   create(
+        #   #     :user
+        #   #   )
+        #   #   build(
+        #   #     :user,
+        #   #     name: 'foo'
+        #   #   )
+        #   #
+        #   class ConsistentParenthesesStyle < ::RuboCop::Cop::Base; end
+        ConsistentParenthesesStyle =
+          ::RuboCop::Cop::FactoryBot::ConsistentParenthesesStyle
       end
     end
   end

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

@@ -4,256 +4,36 @@ module RuboCop
   module Cop
     module RSpec
       module FactoryBot
-        # Checks for create_list usage.
-        #
-        # This cop can be configured using the `EnforcedStyle` option
-        #
-        # @example `EnforcedStyle: create_list` (default)
-        #   # bad
-        #   3.times { create :user }
-        #
-        #   # good
-        #   create_list :user, 3
-        #
-        #   # bad
-        #   3.times { create :user, age: 18 }
-        #
-        #   # good - index is used to alter the created models attributes
-        #   3.times { |n| create :user, age: n }
-        #
-        #   # good - contains a method call, may return different values
-        #   3.times { create :user, age: rand }
-        #
-        # @example `EnforcedStyle: n_times`
-        #   # bad
-        #   create_list :user, 3
-        #
-        #   # good
-        #   3.times { create :user }
-        #
-        class CreateList < ::RuboCop::Cop::Base
-          extend AutoCorrector
-          include ConfigurableEnforcedStyle
-          include RuboCop::RSpec::FactoryBot::Language
-
-          MSG_CREATE_LIST = 'Prefer create_list.'
-          MSG_N_TIMES = 'Prefer %<number>s.times.'
-          RESTRICT_ON_SEND = %i[create_list].freeze
-
-          # @!method array_new_or_n_times_block?(node)
-          def_node_matcher :array_new_or_n_times_block?, <<-PATTERN
-            (block
-              {
-                (send (const {nil? | cbase} :Array) :new (int _)) |
-                (send (int _) :times)
-              }
-              ...
-            )
-          PATTERN
-
-          # @!method block_with_arg_and_used?(node)
-          def_node_matcher :block_with_arg_and_used?, <<-PATTERN
-            (block
-              _
-              (args (arg _value))
-              `_value
-            )
-          PATTERN
-
-          # @!method arguments_include_method_call?(node)
-          def_node_matcher :arguments_include_method_call?, <<-PATTERN
-            (send ${nil? #factory_bot?} :create (sym $_) `$(send ...))
-          PATTERN
-
-          # @!method factory_call(node)
-          def_node_matcher :factory_call, <<-PATTERN
-            (send ${nil? #factory_bot?} :create (sym $_) $...)
-          PATTERN
-
-          # @!method factory_list_call(node)
-          def_node_matcher :factory_list_call, <<-PATTERN
-            (send {nil? #factory_bot?} :create_list (sym _) (int $_) ...)
-          PATTERN
-
-          def on_block(node) # rubocop:todo InternalAffairs/NumblockHandler
-            return unless style == :create_list
-
-            return unless array_new_or_n_times_block?(node)
-            return if block_with_arg_and_used?(node)
-            return unless node.body
-            return if arguments_include_method_call?(node.body)
-            return unless contains_only_factory?(node.body)
-
-            add_offense(node.send_node, message: MSG_CREATE_LIST) do |corrector|
-              CreateListCorrector.new(node.send_node).call(corrector)
-            end
-          end
-
-          def on_send(node)
-            return unless style == :n_times
-
-            factory_list_call(node) do |count|
-              message = format(MSG_N_TIMES, number: count)
-              add_offense(node.loc.selector, message: message) do |corrector|
-                TimesCorrector.new(node).call(corrector)
-              end
-            end
-          end
-
-          private
-
-          def contains_only_factory?(node)
-            if node.block_type?
-              factory_call(node.send_node)
-            else
-              factory_call(node)
-            end
-          end
-
-          # :nodoc
-          module Corrector
-            private
-
-            def build_options_string(options)
-              options.map(&:source).join(', ')
-            end
-
-            def format_method_call(node, method, arguments)
-              if node.block_type? || node.parenthesized?
-                "#{method}(#{arguments})"
-              else
-                "#{method} #{arguments}"
-              end
-            end
-
-            def format_receiver(receiver)
-              return '' unless receiver
-
-              "#{receiver.source}."
-            end
-          end
-
-          # :nodoc
-          class TimesCorrector
-            include Corrector
-
-            def initialize(node)
-              @node = node
-            end
-
-            def call(corrector)
-              replacement = generate_n_times_block(node)
-              corrector.replace(node.block_node || node, replacement)
-            end
-
-            private
-
-            attr_reader :node
-
-            def generate_n_times_block(node)
-              factory, count, *options = node.arguments
-
-              arguments = factory.source
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-
-              replacement = format_receiver(node.receiver)
-              replacement += format_method_call(node, 'create', arguments)
-              replacement += " #{factory_call_block_source}" if node.block_node
-              "#{count.source}.times { #{replacement} }"
-            end
-
-            def factory_call_block_source
-              node.block_node.location.begin.with(
-                end_pos: node.block_node.location.end.end_pos
-              ).source
-            end
-          end
-
-          # :nodoc:
-          class CreateListCorrector
-            include Corrector
-
-            def initialize(node)
-              @node = node.parent
-            end
-
-            def call(corrector)
-              replacement = if node.body.block_type?
-                              call_with_block_replacement(node)
-                            else
-                              call_replacement(node)
-                            end
-
-              corrector.replace(node, replacement)
-            end
-
-            private
-
-            attr_reader :node
-
-            def call_with_block_replacement(node)
-              block = node.body
-              arguments = build_arguments(block, count_from(node))
-              replacement = format_receiver(block.receiver)
-              replacement += format_method_call(block, 'create_list', arguments)
-              replacement += format_block(block)
-              replacement
-            end
-
-            def build_arguments(node, count)
-              factory, *options = *node.send_node.arguments
-
-              arguments = ":#{factory.value}, #{count}"
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-              arguments
-            end
-
-            def call_replacement(node)
-              block = node.body
-              factory, *options = *block.arguments
-
-              arguments = "#{factory.source}, #{count_from(node)}"
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-
-              replacement = format_receiver(block.receiver)
-              replacement += format_method_call(block, 'create_list', arguments)
-              replacement
-            end
-
-            def count_from(node)
-              count_node =
-                if node.receiver.int_type?
-                  node.receiver
-                else
-                  node.send_node.first_argument
-                end
-              count_node.source
-            end
-
-            def format_block(node)
-              if node.body.begin_type?
-                format_multiline_block(node)
-              else
-                format_singleline_block(node)
-              end
-            end
-
-            def format_multiline_block(node)
-              indent = ' ' * node.body.loc.column
-              indent_end = ' ' * node.parent.loc.column
-              " do #{node.arguments.source}\n" \
-                "#{indent}#{node.body.source}\n" \
-                "#{indent_end}end"
-            end
-
-            def format_singleline_block(node)
-              " { #{node.arguments.source} #{node.body.source} }"
-            end
-          end
-        end
+        # @!parse
+        #   # Checks for create_list usage.
+        #   #
+        #   # This cop can be configured using the `EnforcedStyle` option
+        #   #
+        #   # @example `EnforcedStyle: create_list` (default)
+        #   #   # bad
+        #   #   3.times { create :user }
+        #   #
+        #   #   # good
+        #   #   create_list :user, 3
+        #   #
+        #   #   # bad
+        #   #   3.times { create :user, age: 18 }
+        #   #
+        #   #   # good - index is used to alter the created models attributes
+        #   #   3.times { |n| create :user, age: n }
+        #   #
+        #   #   # good - contains a method call, may return different values
+        #   #   3.times { create :user, age: rand }
+        #   #
+        #   # @example `EnforcedStyle: n_times`
+        #   #   # bad
+        #   #   create_list :user, 3
+        #   #
+        #   #   # good
+        #   #   3.times { create :user }
+        #   #
+        #   class CreateList < ::RuboCop::Cop::Base; end
+        CreateList = ::RuboCop::Cop::FactoryBot::CreateList
       end
     end
   end