rubocop-rspec 2.21.0 → 3.0.1

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Use shorthands from `FactoryBot::Syntax::Methods` in your specs.
-        #
-        # @safety
-        #   The autocorrection is marked as unsafe because the cop
-        #   cannot verify whether you already include
-        #   `FactoryBot::Syntax::Methods` in your test suite.
-        #
-        #   If you're using Rails, add the following configuration to
-        #   `spec/support/factory_bot.rb` and be sure to require that file in
-        #   `rails_helper.rb`:
-        #
-        #   [source,ruby]
-        #   ----
-        #   RSpec.configure do |config|
-        #     config.include FactoryBot::Syntax::Methods
-        #   end
-        #   ----
-        #
-        #   If you're not using Rails:
-        #
-        #   [source,ruby]
-        #   ----
-        #   RSpec.configure do |config|
-        #     config.include FactoryBot::Syntax::Methods
-        #
-        #     config.before(:suite) do
-        #       FactoryBot.find_definitions
-        #     end
-        #   end
-        #   ----
-        #
-        # @example
-        #   # bad
-        #   FactoryBot.create(:bar)
-        #   FactoryBot.build(:bar)
-        #   FactoryBot.attributes_for(:bar)
-        #
-        #   # good
-        #   create(:bar)
-        #   build(:bar)
-        #   attributes_for(:bar)
-        #
-        class SyntaxMethods < Base
-          extend AutoCorrector
-          include InsideExampleGroup
-          include RangeHelp
-          include RuboCop::RSpec::FactoryBot::Language
-
-          MSG = 'Use `%<method>s` from `FactoryBot::Syntax::Methods`.'
-
-          RESTRICT_ON_SEND = RuboCop::RSpec::FactoryBot::Language::METHODS
-
-          def on_send(node)
-            return unless factory_bot?(node.receiver)
-            return unless inside_example_group?(node)
-
-            message = format(MSG, method: node.method_name)
-
-            add_offense(crime_scene(node), message: message) do |corrector|
-              corrector.remove(offense(node))
-            end
-          end
-
-          private
-
-          def crime_scene(node)
-            range_between(
-              node.source_range.begin_pos,
-              node.loc.selector.end_pos
-            )
-          end
-
-          def offense(node)
-            range_between(
-              node.source_range.begin_pos,
-              node.loc.selector.begin_pos
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that spec file paths are consistent and well-formed.
-      #
-      # By default, this checks that spec file paths are consistent with the
-      # test subject and enforces that it reflects the described
-      # class/module and its optionally called out method.
-      #
-      # With the configuration option `IgnoreMethods` the called out method will
-      # be ignored when determining the enforced path.
-      #
-      # With the configuration option `CustomTransform` modules or classes can
-      # be specified that should not as usual be transformed from CamelCase to
-      # snake_case (e.g. 'RuboCop' => 'rubocop' ).
-      #
-      # With the configuration option `SpecSuffixOnly` test files will only
-      # be checked to ensure they end in '_spec.rb'. This option disables
-      # checking for consistency in the test subject or test methods.
-      #
-      # @example
-      #   # bad
-      #   whatever_spec.rb         # describe MyClass
-      #
-      #   # bad
-      #   my_class_spec.rb         # describe MyClass, '#method'
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_method_spec.rb  # describe MyClass, '#method'
-      #
-      #   # good
-      #   my_class/method_spec.rb  # describe MyClass, '#method'
-      #
-      # @example when configuration is `IgnoreMethods: true`
-      #   # bad
-      #   whatever_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass, '#method'
-      #
-      # @example when configuration is `SpecSuffixOnly: true`
-      #   # good
-      #   whatever_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass, '#method'
-      #
-      class FilePath < Base
-        include TopLevelGroup
-        include Namespace
-
-        MSG = 'Spec path should end with `%<suffix>s`.'
-
-        # @!method example_group(node)
-        def_node_matcher :example_group, <<~PATTERN
-          (block
-            $(send #rspec? _example_group $_ $...) ...
-          )
-        PATTERN
-
-        # @!method routing_metadata?(node)
-        def_node_search :routing_metadata?, '(pair (sym :type) (sym :routing))'
-
-        def on_top_level_example_group(node)
-          return unless top_level_groups.one?
-
-          example_group(node) do |send_node, example_group, arguments|
-            ensure_correct_file_path(send_node, example_group, arguments)
-          end
-        end
-
-        private
-
-        def ensure_correct_file_path(send_node, example_group, arguments)
-          pattern = pattern_for(example_group, arguments)
-          return if filename_ends_with?(pattern)
-
-          # For the suffix shown in the offense message, modify the regular
-          # expression pattern to resemble a glob pattern for clearer error
-          # messages.
-          offense_suffix = pattern.gsub('.*', '*').sub('[^/]', '')
-            .sub('\.', '.')
-          add_offense(send_node, message: format(MSG, suffix: offense_suffix))
-        end
-
-        def routing_spec?(args)
-          args.any?(&method(:routing_metadata?)) || routing_spec_path?
-        end
-
-        def pattern_for(example_group, arguments)
-          method_name = arguments.first
-          if spec_suffix_only? || !example_group.const_type? ||
-              routing_spec?(arguments)
-            return pattern_for_spec_suffix_only
-          end
-
-          [
-            expected_path(example_group),
-            name_pattern(method_name),
-            '[^/]*_spec\.rb'
-          ].join
-        end
-
-        def pattern_for_spec_suffix_only
-          '.*_spec\.rb'
-        end
-
-        def name_pattern(method_name)
-          return unless method_name&.str_type?
-          return if ignore_methods?
-
-          ".*#{method_name.str_content.gsub(/\s/, '_').gsub(/\W/, '')}"
-        end
-
-        def expected_path(constant)
-          constants = namespace(constant) + constant.const_name.split('::')
-
-          File.join(
-            constants.map do |name|
-              custom_transform.fetch(name) { camel_to_snake_case(name) }
-            end
-          )
-        end
-
-        def camel_to_snake_case(string)
-          string
-            .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
-            .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
-            .downcase
-        end
-
-        def custom_transform
-          cop_config.fetch('CustomTransform', {})
-        end
-
-        def ignore_methods?
-          cop_config['IgnoreMethods']
-        end
-
-        def filename_ends_with?(pattern)
-          expanded_file_path.match?("#{pattern}$")
-        end
-
-        def relevant_rubocop_rspec_file?(_file)
-          true
-        end
-
-        def spec_suffix_only?
-          cop_config['SpecSuffixOnly']
-        end
-
-        def routing_spec_path?
-          expanded_file_path.include?('spec/routing/')
-        end
-
-        def expanded_file_path
-          File.expand_path(processed_source.file_path)
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Rails
-        # Checks that tests use RSpec `before` hook over Rails `setup` method.
-        #
-        # @example
-        #   # bad
-        #   setup do
-        #     allow(foo).to receive(:bar)
-        #   end
-        #
-        #   # good
-        #   before do
-        #     allow(foo).to receive(:bar)
-        #   end
-        #
-        class AvoidSetupHook < Base
-          extend AutoCorrector
-
-          MSG = 'Use `before` instead of `setup`.'
-
-          # @!method setup_call(node)
-          def_node_matcher :setup_call, <<-PATTERN
-            (block
-              $(send nil? :setup)
-              (args) _)
-          PATTERN
-
-          def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
-            setup_call(node) do |setup|
-              add_offense(node) do |corrector|
-                corrector.replace setup, 'before'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Rails
-        # Checks that tests use `have_http_status` instead of equality matchers.
-        #
-        # @example
-        #   # bad
-        #   expect(response.status).to be(200)
-        #   expect(response.code).to eq("200")
-        #
-        #   # good
-        #   expect(response).to have_http_status(200)
-        #
-        class HaveHttpStatus < ::RuboCop::Cop::Base
-          extend AutoCorrector
-
-          MSG =
-            'Prefer `expect(response).%<to>s have_http_status(%<status>s)` ' \
-            'over `%<bad_code>s`.'
-
-          RUNNERS = %i[to to_not not_to].to_set
-          RESTRICT_ON_SEND = RUNNERS
-
-          # @!method match_status(node)
-          def_node_matcher :match_status, <<-PATTERN
-            (send
-              (send nil? :expect
-                $(send (send nil? :response) {:status :code})
-              )
-              $RUNNERS
-              $(send nil? {:be :eq :eql :equal} ({int str} $_))
-            )
-          PATTERN
-
-          def on_send(node)
-            match_status(node) do |response_status, to, match, status|
-              return unless status.to_s.match?(/\A\d+\z/)
-
-              message = format(MSG, to: to, status: status,
-                                    bad_code: node.source)
-              add_offense(node, message: message) do |corrector|
-                corrector.replace(response_status, 'response')
-                corrector.replace(match.loc.selector, 'have_http_status')
-                corrector.replace(match.first_argument, status.to_s)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/utils'
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Rails
-        # Enforces use of symbolic or numeric value to describe HTTP status.
-        #
-        # This cop inspects only `have_http_status` calls.
-        # So, this cop does not check if a method starting with `be_*` is used
-        # when setting for `EnforcedStyle: symbolic` or
-        # `EnforcedStyle: numeric`.
-        #
-        # @example `EnforcedStyle: symbolic` (default)
-        #   # bad
-        #   it { is_expected.to have_http_status 200 }
-        #   it { is_expected.to have_http_status 404 }
-        #
-        #   # good
-        #   it { is_expected.to have_http_status :ok }
-        #   it { is_expected.to have_http_status :not_found }
-        #   it { is_expected.to have_http_status :success }
-        #   it { is_expected.to have_http_status :error }
-        #
-        # @example `EnforcedStyle: numeric`
-        #   # bad
-        #   it { is_expected.to have_http_status :ok }
-        #   it { is_expected.to have_http_status :not_found }
-        #
-        #   # good
-        #   it { is_expected.to have_http_status 200 }
-        #   it { is_expected.to have_http_status 404 }
-        #   it { is_expected.to have_http_status :success }
-        #   it { is_expected.to have_http_status :error }
-        #
-        # @example `EnforcedStyle: be_status`
-        #   # bad
-        #   it { is_expected.to have_http_status :ok }
-        #   it { is_expected.to have_http_status :not_found }
-        #   it { is_expected.to have_http_status 200 }
-        #   it { is_expected.to have_http_status 404 }
-        #
-        #   # good
-        #   it { is_expected.to be_ok }
-        #   it { is_expected.to be_not_found }
-        #   it { is_expected.to have_http_status :success }
-        #   it { is_expected.to have_http_status :error }
-        #
-        class HttpStatus < Base
-          extend AutoCorrector
-          include ConfigurableEnforcedStyle
-          RESTRICT_ON_SEND = %i[have_http_status].freeze
-
-          # @!method http_status(node)
-          def_node_matcher :http_status, <<-PATTERN
-            (send nil? :have_http_status ${int sym})
-          PATTERN
-
-          def on_send(node)
-            http_status(node) do |arg|
-              checker = checker_class.new(arg)
-              return unless checker.offensive?
-
-              add_offense(checker.offense_range,
-                          message: checker.message) do |corrector|
-                corrector.replace(checker.offense_range, checker.prefer)
-              end
-            end
-          end
-
-          private
-
-          def checker_class
-            case style
-            when :symbolic
-              SymbolicStyleChecker
-            when :numeric
-              NumericStyleChecker
-            when :be_status
-              BeStatusStyleChecker
-            end
-          end
-
-          # :nodoc:
-          class StyleCheckerBase
-            MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                  'to describe HTTP status code.'
-            ALLOWED_STATUSES = %i[error success missing redirect].freeze
-
-            attr_reader :node
-
-            def initialize(node)
-              @node = node
-            end
-
-            def message
-              format(MSG, prefer: prefer, current: current)
-            end
-
-            def offense_range
-              node
-            end
-
-            def allowed_symbol?
-              node.sym_type? && ALLOWED_STATUSES.include?(node.value)
-            end
-
-            def custom_http_status_code?
-              node.int_type? &&
-                !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(node.source.to_i)
-            end
-          end
-
-          # :nodoc:
-          class SymbolicStyleChecker < StyleCheckerBase
-            def offensive?
-              !node.sym_type? && !custom_http_status_code?
-            end
-
-            def prefer
-              symbol.inspect
-            end
-
-            def current
-              number.inspect
-            end
-
-            private
-
-            def symbol
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
-            end
-
-            def number
-              node.source.to_i
-            end
-          end
-
-          # :nodoc:
-          class NumericStyleChecker < StyleCheckerBase
-            def offensive?
-              !node.int_type? && !allowed_symbol?
-            end
-
-            def prefer
-              number.to_s
-            end
-
-            def current
-              symbol.inspect
-            end
-
-            private
-
-            def symbol
-              node.value
-            end
-
-            def number
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
-            end
-          end
-
-          # :nodoc:
-          class BeStatusStyleChecker < StyleCheckerBase
-            def offensive?
-              (!node.sym_type? && !custom_http_status_code?) ||
-                (!node.int_type? && !allowed_symbol?)
-            end
-
-            def offense_range
-              node.parent
-            end
-
-            def prefer
-              if node.sym_type?
-                "be_#{node.value}"
-              else
-                "be_#{symbol}"
-              end
-            end
-
-            def current
-              offense_range.source
-            end
-
-            private
-
-            def symbol
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
-            end
-
-            def number
-              node.source.to_i
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,145 +0,0 @@
-# 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/Rails/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(remove_range(node))
-          end
-
-          # @param [RuboCop::AST::Node] node
-          # @return [Parser::Source::Range]
-          def remove_range(node)
-            if node.left_sibling
-              node.source_range.with(
-                begin_pos: node.left_sibling.source_range.end_pos
-              )
-            elsif node.right_sibling
-              node.source_range.with(
-                end_pos: node.right_sibling.source_range.begin_pos
-              )
-            end
-          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