fablicop 1.10.1 → 1.10.3

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rspec-2.22.0/lib/rubocop/cop/rspec/rails/http_status.rb

@@ -0,0 +1,203 @@
+# 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/vendor/bundle/ruby/3.2.0/gems/rubocop-rspec-2.22.0/lib/rubocop/cop/rspec/rails/inferred_spec_type.rb

@@ -0,0 +1,145 @@
+# 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

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rspec-2.22.0/lib/rubocop/cop/rspec/rails/minitest_assertions.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Rails
+        # Check if using Minitest matchers.
+        #
+        # @example
+        #   # bad
+        #   assert_equal(a, b)
+        #   assert_equal a, b, "must be equal"
+        #   refute_equal(a, b)
+        #
+        #   # good
+        #   expect(b).to eq(a)
+        #   expect(b).to(eq(a), "must be equal")
+        #   expect(b).not_to eq(a)
+        #
+        class MinitestAssertions < Base
+          extend AutoCorrector
+
+          MSG = 'Use `%<prefer>s`.'
+          RESTRICT_ON_SEND = %i[assert_equal refute_equal].freeze
+
+          # @!method minitest_assertion(node)
+          def_node_matcher :minitest_assertion, <<-PATTERN
+          (send nil? {:assert_equal :refute_equal} $_ $_ $_?)
+          PATTERN
+
+          def on_send(node)
+            minitest_assertion(node) do |expected, actual, failure_message|
+              prefer = replacement(node, expected, actual,
+                                   failure_message.first)
+              add_offense(node, message: message(prefer)) do |corrector|
+                corrector.replace(node, prefer)
+              end
+            end
+          end
+
+          private
+
+          def replacement(node, expected, actual, failure_message)
+            runner = node.method?(:assert_equal) ? 'to' : 'not_to'
+            if failure_message.nil?
+              "expect(#{actual.source}).#{runner} eq(#{expected.source})"
+            else
+              "expect(#{actual.source}).#{runner}(eq(#{expected.source}), " \
+                "#{failure_message.source})"
+            end
+          end
+
+          def message(prefer)
+            format(MSG, prefer: prefer)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rspec-2.22.0/lib/rubocop/cop/rspec/rails/travel_around.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Rails
+        # Prefer to travel in `before` rather than `around`.
+        #
+        # @safety
+        #   This cop is unsafe because the automatic `travel_back` is only run
+        #   on test cases that are considered as Rails related.
+        #
+        #   And also, this cop's autocorrection is unsafe because the order of
+        #   execution will change if other steps exist before traveling in
+        #   `around`.
+        #
+        # @example
+        #   # bad
+        #   around do |example|
+        #     freeze_time do
+        #       example.run
+        #     end
+        #   end
+        #
+        #   # good
+        #   before { freeze_time }
+        class TravelAround < Base
+          extend AutoCorrector
+
+          MSG = 'Prefer to travel in `before` rather than `around`.'
+
+          TRAVEL_METHOD_NAMES = %i[
+            freeze_time
+            travel
+            travel_to
+          ].to_set.freeze
+
+          # @!method extract_run_in_travel(node)
+          def_node_matcher :extract_run_in_travel, <<~PATTERN
+            (block
+              $(send nil? TRAVEL_METHOD_NAMES ...)
+              (args ...)
+              (send _ :run)
+            )
+          PATTERN
+
+          # @!method match_around_each?(node)
+          def_node_matcher :match_around_each?, <<~PATTERN
+            (block
+              (send _ :around (sym :each)?)
+              ...
+            )
+          PATTERN
+
+          def on_block(node)
+            run_node = extract_run_in_travel(node)
+            return unless run_node
+
+            around_node = extract_surrounding_around_block(run_node)
+            return unless around_node
+
+            add_offense(node) do |corrector|
+              autocorrect(corrector, node, run_node, around_node)
+            end
+          end
+          alias on_numblock on_block
+
+          private
+
+          def autocorrect(corrector, node, run_node, around_node)
+            corrector.replace(
+              node,
+              node.body.source
+            )
+            corrector.insert_before(
+              around_node,
+              "before { #{run_node.source} }\n\n"
+            )
+          end
+
+          # @param node [RuboCop::AST::BlockNode]
+          # @return [RuboCop::AST::BlockNode, nil]
+          def extract_surrounding_around_block(node)
+            node.each_ancestor(:block).find do |ancestor|
+              match_around_each?(ancestor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rspec-2.22.0/lib/rubocop/cop/rspec/receive_counts.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for `once` and `twice` receive counts matchers usage.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to receive(:bar).exactly(1).times
+      #   expect(foo).to receive(:bar).exactly(2).times
+      #   expect(foo).to receive(:bar).at_least(1).times
+      #   expect(foo).to receive(:bar).at_least(2).times
+      #   expect(foo).to receive(:bar).at_most(1).times
+      #   expect(foo).to receive(:bar).at_most(2).times
+      #
+      #   # good
+      #   expect(foo).to receive(:bar).once
+      #   expect(foo).to receive(:bar).twice
+      #   expect(foo).to receive(:bar).at_least(:once)
+      #   expect(foo).to receive(:bar).at_least(:twice)
+      #   expect(foo).to receive(:bar).at_most(:once)
+      #   expect(foo).to receive(:bar).at_most(:twice).times
+      #
+      class ReceiveCounts < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<alternative>s` instead of `%<original>s`.'
+
+        RESTRICT_ON_SEND = %i[times].freeze
+
+        # @!method receive_counts(node)
+        def_node_matcher :receive_counts, <<-PATTERN
+          (send $(send _ {:exactly :at_least :at_most} (int {1 2})) :times)
+        PATTERN
+
+        # @!method stub?(node)
+        def_node_search :stub?, '(send nil? :receive ...)'
+
+        def on_send(node)
+          receive_counts(node) do |offending_node|
+            return unless stub?(offending_node.receiver)
+
+            offending_range = range(node, offending_node)
+
+            msg = message_for(offending_node, offending_range.source)
+            add_offense(offending_range, message: msg) do |corrector|
+              autocorrect(corrector, offending_node, offending_range)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node, range)
+          replacement = matcher_for(
+            node.method_name,
+            node.first_argument.source.to_i
+          )
+
+          corrector.replace(range, replacement)
+        end
+
+        def message_for(node, source)
+          alternative = matcher_for(
+            node.method_name,
+            node.first_argument.source.to_i
+          )
+          format(MSG, alternative: alternative, original: source)
+        end
+
+        def matcher_for(method, count)
+          matcher = count == 1 ? 'once' : 'twice'
+          if method == :exactly
+            ".#{matcher}"
+          else
+            ".#{method}(:#{matcher})"
+          end
+        end
+
+        def range(node, offending_node)
+          offending_node.loc.dot.with(
+            end_pos: node.source_range.end_pos
+          )
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rspec-2.22.0/lib/rubocop/cop/rspec/receive_never.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Prefer `not_to receive(...)` over `receive(...).never`.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to receive(:bar).never
+      #
+      #   # good
+      #   expect(foo).not_to receive(:bar)
+      #
+      class ReceiveNever < Base
+        extend AutoCorrector
+        MSG = 'Use `not_to receive` instead of `never`.'
+        RESTRICT_ON_SEND = %i[never].freeze
+
+        # @!method method_on_stub?(node)
+        def_node_search :method_on_stub?, '(send nil? :receive ...)'
+
+        def on_send(node)
+          return unless node.method?(:never) && method_on_stub?(node)
+
+          add_offense(node.loc.selector) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node.parent.loc.selector, 'not_to')
+          range = node.loc.dot.with(end_pos: node.loc.selector.end_pos)
+          corrector.remove(range)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rspec-2.22.0/lib/rubocop/cop/rspec/redundant_around.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Remove redundant `around` hook.
+      #
+      # @example
+      #   # bad
+      #   around do |example|
+      #     example.run
+      #   end
+      #
+      #   # good
+      #
+      class RedundantAround < Base
+        extend AutoCorrector
+
+        MSG = 'Remove redundant `around` hook.'
+
+        RESTRICT_ON_SEND = %i[around].freeze
+
+        def on_block(node)
+          return unless match_redundant_around_hook_block?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+        alias on_numblock on_block
+
+        def on_send(node)
+          return unless match_redundant_around_hook_send?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method match_redundant_around_hook_block?(node)
+        def_node_matcher :match_redundant_around_hook_block?, <<~PATTERN
+          ({block numblock} (send _ :around ...) ... (send _ :run))
+        PATTERN
+
+        # @!method match_redundant_around_hook_send?(node)
+        def_node_matcher :match_redundant_around_hook_send?, <<~PATTERN
+          (send
+            _
+            :around
+            ...
+            (block-pass
+              (sym :run)
+            )
+          )
+        PATTERN
+
+        def autocorrect(corrector, node)
+          corrector.remove(node)
+        end
+      end
+    end
+  end
+end