rubocop-rspec 2.21.0 → 3.0.1

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

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-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.source_range
-            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
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# 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
-        #
-        #   # 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
-
-          AMBIGUOUS_TYPES = %i[send pair array and or if].freeze
-
-          def ambiguous_without_parentheses?(node)
-            node.parent && AMBIGUOUS_TYPES.include?(node.parent.type)
-          end
-
-          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

@@ -1,260 +0,0 @@
-# frozen_string_literal: true
-
-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
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Use string value when setting the class attribute explicitly.
-        #
-        # This cop would promote faster tests by lazy-loading of
-        # application files. Also, this could help you suppress potential bugs
-        # in combination with external libraries by avoiding a preload of
-        # application files from the factory files.
-        #
-        # @example
-        #   # bad
-        #   factory :foo, class: Foo do
-        #   end
-        #
-        #   # good
-        #   factory :foo, class: 'Foo' do
-        #   end
-        #
-        class FactoryClassName < ::RuboCop::Cop::Base
-          extend AutoCorrector
-
-          MSG = "Pass '%<class_name>s' string instead of `%<class_name>s` " \
-                'constant.'
-          ALLOWED_CONSTANTS = %w[Hash OpenStruct].freeze
-          RESTRICT_ON_SEND = %i[factory].freeze
-
-          # @!method class_name(node)
-          def_node_matcher :class_name, <<~PATTERN
-            (send _ :factory _ (hash <(pair (sym :class) $(const ...)) ...>))
-          PATTERN
-
-          def on_send(node)
-            class_name(node) do |cn|
-              next if allowed?(cn.const_name)
-
-              msg = format(MSG, class_name: cn.const_name)
-              add_offense(cn, message: msg) do |corrector|
-                corrector.replace(cn, "'#{cn.source}'")
-              end
-            end
-          end
-
-          private
-
-          def allowed?(const_name)
-            ALLOWED_CONSTANTS.include?(const_name)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Checks for name style for argument of FactoryBot::Syntax::Methods.
-        #
-        # @example EnforcedStyle: symbol (default)
-        #   # bad
-        #   create('user')
-        #   build "user", username: "NAME"
-        #
-        #   # good
-        #   create(:user)
-        #   build :user, username: "NAME"
-        #
-        # @example EnforcedStyle: string
-        #   # bad
-        #   create(:user)
-        #   build :user, username: "NAME"
-        #
-        #   # good
-        #   create('user')
-        #   build "user", username: "NAME"
-        #
-        class FactoryNameStyle < ::RuboCop::Cop::Base
-          extend AutoCorrector
-          include ConfigurableEnforcedStyle
-          include RuboCop::RSpec::FactoryBot::Language
-
-          MSG = 'Use %<prefer>s to refer to a factory.'
-          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
-            ${str sym} ...
-          )
-          PATTERN
-
-          def on_send(node)
-            factory_call(node) do |name|
-              if offense_for_symbol_style?(name)
-                register_offense(name, name.value.to_sym.inspect)
-              elsif offense_for_string_style?(name)
-                register_offense(name, name.value.to_s.inspect)
-              end
-            end
-          end
-
-          private
-
-          def offense_for_symbol_style?(name)
-            name.str_type? && style == :symbol
-          end
-
-          def offense_for_string_style?(name)
-            name.sym_type? && style == :string
-          end
-
-          def register_offense(name, prefer)
-            add_offense(name,
-                        message: format(MSG, prefer: style.to_s)) do |corrector|
-              corrector.replace(name, prefer)
-            end
-          end
-        end
-      end
-    end
-  end
-end