rubocop-petal 1.1.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50feab9f7db5e7eb2bc4e1cf84a7f2273bd954f116be6901582e07d1e2c1150c
-  data.tar.gz: c4ce73b925d3811bf92a1779314a592701157b22daa4f0f7885e7d074dd1f1d5
+  metadata.gz: 15da074670760958ac74e715caa688618632bcbb5379e5fc47dd1a1055c8e956
+  data.tar.gz: 0d70524ec6b85733e931c09c864151454cde3fc4287c87f6a1722d1d3c6ea81d
 SHA512:
-  metadata.gz: 5385ce76c50bcd195adcd658300e0a10ccb7e5c01e518ea15842530de709066e9016b411bf1c605e30760830c6b1ad210583834efafb1fea99b46bb72eef1876
-  data.tar.gz: 42b2ed6467edce4b0cdccf153d7258b2e69bf52d2cfcc0809f720d01d0865016cd5c0d0dfabff53af45d30d2c33bcd85aad6f7867418c10883cfff28474f94ea
+  metadata.gz: 2271b3c9bdc14b033c248ec2b7492a2248e017c98a48daded7cee9621e4e5a42c5c30f8036b5c16fcd182408af56d6b213ee9c6a8f719c65506f913aac741b1e
+  data.tar.gz: 8780348f8074c78603b2fc8988297c12f4531080bd07f54af0cdaa4d9b63d021f5328b8e192b0c8cb34ee53d4933e3d04769240f6907e550a8e7c4e6e042f965

data/config/base.yml

@@ -65,8 +65,6 @@ RSpec/LetSetup:
   Enabled: false
 RSpec/MessageSpies:
   EnforcedStyle: receive
-RSpec/MultipleExpectations:
-  Enabled: false
 RSpec/MultipleMemoizedHelpers:
   Enabled: false
 RSpec/NamedSubject:

data/config/default.yml

@@ -1,3 +1,9 @@
+Chewy/FieldType:
+  Description: 'Assure that a type is defined for a Chewy field.'
+  Enabled: true
+  Include:
+    - app/chewy/**/*
+
 Grape/PreferNamespace:
   Description: 'Prevent usage of namespace aliases.'
   Enabled: true
@@ -29,6 +35,26 @@ Migration/SchemaStatementsMethods:
   Include:
     - db/migrate/**
 
+Migration/StandaloneAddReference:
+  Description: 'Prevent using `add_reference/belongs_to` outside of a change_table.'
+  Enabled: true
+  Include:
+    - db/migrate/**
+
+RSpec/AggregateExamples:
+  Description: Checks if example group contains two or more aggregatable examples.
+  Enabled: true
+  StyleGuide: https://rspec.rubystyle.guide/#expectation-per-example
+  AddAggregateFailuresMetadata: true
+  MatchersWithSideEffects:
+    - allow_value
+    - allow_values
+    - validate_presence_of
+    - validate_absence_of
+    - validate_length_of
+    - validate_inclusion_of
+    - validates_exclusion_of
+
 RSpec/AuthenticatedAs:
   Description: 'Suggest to use authenticated_as instead of legacy api_key.'
   Enabled: true
@@ -68,6 +94,11 @@ Grape/UnnecessaryNamespace:
   Include:
     - app/api/**/*
 
+Rails/DestroyAllBang:
+  Description: 'Prevent using `destroy_all` in favor of `each(&:destroy!)` to go along Rails/SaveBang cop.'
+  StyleGuide: https://rails.rubystyle.guide#save-bang
+  Enabled: true
+
 Rails/EnumPrefix:
   Description: 'Set prefix options when using enums.'
   Enabled: true
@@ -75,6 +106,13 @@ Rails/EnumPrefix:
   Include:
     - app/models/**/*
 
+Rails/EnumStartingValue:
+  Description: 'Prevent starting from zero with an enum.'
+  Enabled: true
+  StyleGuide: https://github.com/petalmd/rubocop-petal/issues/56
+  Include:
+    - app/models/**/*
+
 Rails/RiskyActiverecordInvocation:
   Description: 'Interpolation, use hash or parameterized syntax.'
   Enabled: true
@@ -93,3 +131,7 @@ RSpec/JsonResponse:
 Performance/Snif:
   Description: 'Prevent snif in favor of detect'
   Enabled: true
+
+Sidekiq/NoNilReturn:
+  Description: 'Prevent early nil return in workers'
+  Enabled: false

data/lib/rubocop/cop/chewy/field_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Chewy
+      # This cop force to specify a type for Chewy field
+      #
+      #   # bad
+      #   field :name
+      #
+      #   # good
+      #   field :name, type: 'text'
+      class FieldType < Base
+        MSG = 'Specify a `type` for Chewy field.'
+
+        RESTRICT_ON_SEND = %i[field].freeze
+
+        # @!method options_has_field?(node)
+        def_node_matcher :options_has_field?, <<~PATTERN
+          (send nil? :field (sym _)+ (hash <(pair (sym :type) {str sym}) ...>))
+        PATTERN
+
+        def on_send(node)
+          return if options_has_field?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/change_table_references.rb

@@ -21,11 +21,12 @@ module RuboCop
       #     t.foreign_key :users, column: :user_id
       #   end
       class ChangeTableReferences < Base
-        MSG = 'Use a combination of `t.bigint`, `t.index` and `t.foreign_key` in a change_table.'
+        MSG = 'Use a combination of `t.bigint`, `t.index` and `t.foreign_key` in a change_table to add a reference.' \
+              'Or `t.remove_foreign_key`, `t.remove` to remove a reference.'
 
         # @!method add_references_in_block?(node)
-        def_node_search :add_references_in_block?, <<~PATTERN
-          (send lvar /references|belongs_to/ ...)
+        def_node_matcher :add_references_in_block?, <<~PATTERN
+          (send lvar /references|belongs_to|remove_references|remove_belongs_to/ ...)
         PATTERN
 
         # @!method change_table?(node)
@@ -36,7 +37,7 @@ module RuboCop
         def on_block(node)
           return unless change_table?(node)
 
-          references_node = node.children.detect { |n| add_references_in_block?(n) }
+          references_node = node.child_nodes[2].each_node.detect { |n| add_references_in_block?(n) }
           return unless references_node
 
           arguments = references_node.child_nodes[1]

data/lib/rubocop/cop/migration/standalone_add_reference.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Prevent using `add_reference` and `remove_reference` outside of
+      # a `change_table` block. `add_reference` create multiples `ALTER TABLE`
+      # statements. Using `change_table` with `bulk: true` is more efficient.
+      #
+      #  # bad
+      #  add_reference :products, :user, foreign_key: true
+      #
+      #  # good
+      #  change_table :products, bulk: true do |t|
+      #    t.bigint :user_id, null: false
+      #    t.index :user_id
+      #    t.foreign_key :users, column: :user_id
+      #  end
+      class StandaloneAddReference < Base
+        MSG = 'Modifying references must be done in a change_table block.'
+
+        RESTRICT_ON_SEND = %i[add_reference add_belongs_to remove_reference remove_belongs_to].freeze
+
+        def on_send(node)
+          reference_method = node.source_range.with(end_pos: node.child_nodes.first.source_range.begin_pos - 1)
+
+          add_offense(reference_method)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/destroy_all_bang.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Cop to enforce the use of `each(&:destroy!)` over `destroy_all`.
+      # https://docs.rubocop.org/rubocop-rails/cops_rails.html#railssavebang
+      # https://github.com/rails/rails/pull/37782
+      # https://discuss.rubyonrails.org/t/proposal-add-destroy-all-method-to-activerecord-relation/80959
+      #
+      #   # bad
+      #   User.destroy_all
+      #
+      #   # good
+      #   User.each(&:destroy!)
+      class DestroyAllBang < Base
+        extend AutoCorrector
+        MSG = 'Use `each(&:destroy!)` instead of `destroy_all`.'
+        RESTRICT_ON_SEND = %i[destroy_all].freeze
+
+        def on_send(node)
+          destroy_all_range = node.loc.selector
+          add_offense(destroy_all_range) do |corrector|
+            corrector.replace(node.loc.selector, 'each(&:destroy!)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/enum_starting_value.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Prevent the user to start from Zero with an enum.
+      # When using a wrong value like .where(state: :patato) let Rails + MySQL do a WHERE state = 0.
+      # It will match nothing since no record will have a 0 value.
+      #
+      #   # bad
+      #   enum my_enum: {apple: 0, bannana: 1}
+      #
+      #   # good
+      #   enum my_enum: {apple: 1, banana: 2}
+
+      class EnumStartingValue < Base
+        MSG = 'Prefer starting from `1` instead of `0` with `enum`.'
+
+        def_node_matcher :enum?, <<~PATTERN
+          (send nil? :enum (hash ...))
+        PATTERN
+
+        def_node_matcher :enum_attributes, <<~PATTERN
+          (send nil? :enum (:hash (:pair (...)$(...) )...))
+        PATTERN
+
+        def on_send(node)
+          return unless enum? node
+
+          add_offense(node) if start_with_zero?(enum_attributes(node))
+        end
+
+        def start_with_zero?(node)
+          return false unless node.type == :hash
+
+          node.children.any? do |child|
+            value = child.value
+            value.type == :int && value.value.zero?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/aggregate_examples/language.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# This is shamelessly borrowed from RuboCop RSpec
+# https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/language.rb
+module RuboCop
+  module Cop
+    module RSpec
+      # RSpec public API methods that are commonly used in cops
+      class AggregateExamples < ::RuboCop::Cop::Cop
+        module Language
+          RSPEC = '{(const {nil? cbase} :RSpec) nil?}'
+
+          # Set of method selectors
+          class SelectorSet
+            def initialize(selectors)
+              @selectors = selectors
+            end
+
+            def ==(other)
+              selectors.eql?(other.selectors)
+            end
+
+            def +(other)
+              self.class.new(selectors + other.selectors)
+            end
+
+            delegate :include?, to: :selectors
+
+            def block_pattern
+              "(block #{send_pattern} ...)"
+            end
+
+            def send_pattern
+              "(send #{RSPEC} #{node_pattern_union} ...)"
+            end
+
+            def node_pattern_union
+              "{#{node_pattern}}"
+            end
+
+            def node_pattern
+              selectors.map(&:inspect).join(' ')
+            end
+
+            protected
+
+            attr_reader :selectors
+          end
+
+          module ExampleGroups
+            GROUPS = SelectorSet.new(%i[describe context feature example_group])
+            SKIPPED = SelectorSet.new(%i[xdescribe xcontext xfeature])
+            FOCUSED = SelectorSet.new(%i[fdescribe fcontext ffeature])
+
+            ALL = GROUPS + SKIPPED + FOCUSED
+          end
+
+          module Examples
+            EXAMPLES = SelectorSet.new(%i[it specify example scenario its])
+            FOCUSED = SelectorSet.new(%i[fit fspecify fexample fscenario focus])
+            SKIPPED = SelectorSet.new(%i[xit xspecify xexample xscenario skip])
+            PENDING = SelectorSet.new(%i[pending])
+
+            ALL = EXAMPLES + FOCUSED + SKIPPED + PENDING
+          end
+
+          module Runners
+            ALL = SelectorSet.new(%i[to to_not not_to])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/aggregate_examples/line_range_helpers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < ::RuboCop::Cop::Cop
+        # @internal Support methods for keeping newlines around examples.
+        module LineRangeHelpers
+          include RangeHelp
+
+          private
+
+          def range_for_replace(examples)
+            range = range_by_whole_lines(examples.first.source_range,
+                                         include_final_newline: true)
+            next_range = range_by_whole_lines(examples[1].source_range)
+            if adjacent?(range, next_range)
+              range.resize(range.length + 1)
+            else
+              range
+            end
+          end
+
+          def adjacent?(range, another_range)
+            range.end_pos + 1 == another_range.begin_pos
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/aggregate_examples/matchers_with_side_effects.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'language'
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < ::RuboCop::Cop::Cop
+        # When aggregated, the expectations will fail when not supposed to or
+        # have a risk of not failing when expected to. One example is
+        # `validate_presence_of :comment` as it leaves an empty comment after
+        # itself on the subject making it invalid and the subsequent expectation
+        # to fail.
+        # Examples with those matchers are not supposed to be aggregated.
+        #
+        # @example MatchersWithSideEffects
+        #
+        #   # .rubocop.yml
+        #   # RSpec/AggregateExamples:
+        #   #   MatchersWithSideEffects:
+        #   #   - allow_value
+        #   #   - allow_values
+        #   #   - validate_presence_of
+        #
+        #   # bad, but isn't automatically correctable
+        #   describe do
+        #     it { is_expected.to validate_presence_of(:comment) }
+        #     it { is_expected.to be_valid }
+        #   end
+        #
+        # @internal
+        #   Support for taking special care of the matchers that have side
+        #   effects, i.e. leave the subject in a modified state.
+        module MatchersWithSideEffects
+          extend RuboCop::NodePattern::Macros
+          include Language
+
+          MSG_FOR_EXPECTATIONS_WITH_SIDE_EFFECTS =
+            'Aggregate with the example at line %d. IMPORTANT! Pay attention ' \
+            'to the expectation order, some of the matchers have side effects.'
+
+          private
+
+          def message_for(example, first_example)
+            return super unless example_with_side_effects?(example)
+
+            format(MSG_FOR_EXPECTATIONS_WITH_SIDE_EFFECTS, first_example.loc.line)
+          end
+
+          def matcher_with_side_effects_names
+            cop_config.fetch('MatchersWithSideEffects', [])
+              .map(&:to_sym)
+          end
+
+          def matcher_with_side_effects_name?(matcher_name)
+            matcher_with_side_effects_names.include?(matcher_name)
+          end
+
+          # In addition to base definition, matches examples with:
+          # - no matchers known to have side-effects
+          def_node_matcher :example_for_autocorrect?, <<-PATTERN
+            [ #super !#example_with_side_effects? ]
+          PATTERN
+
+          # Matches the example with matcher with side effects
+          def_node_matcher :example_with_side_effects?, <<-PATTERN
+            (block #{Examples::EXAMPLES.send_pattern} _ #expectation_with_side_effects?)
+          PATTERN
+
+          # Matches the expectation with matcher with side effects
+          def_node_matcher :expectation_with_side_effects?, <<-PATTERN
+            (send #expectation? #{Runners::ALL.node_pattern_union} #matcher_with_side_effects?)
+          PATTERN
+
+          # Matches the matcher with side effects
+          def_node_search :matcher_with_side_effects?, <<-PATTERN
+            (send nil? #matcher_with_side_effects_name? ...)
+          PATTERN
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/aggregate_examples/metadata_helpers.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < ::RuboCop::Cop::Cop
+        # @internal
+        #   Support methods for example metadata.
+        #   Examples with similar metadata are grouped.
+        #
+        #   Depending on the configuration, `aggregate_failures` metadata
+        #   is added to aggregated examples.
+        module MetadataHelpers
+          private
+
+          def metadata_for_aggregated_example(metadata)
+            metadata_to_add = metadata.compact.map(&:source)
+            metadata_to_add.unshift(':aggregate_failures') if add_aggregate_failures_metadata?
+            if metadata_to_add.any?
+              "(#{metadata_to_add.join(', ')})"
+            else
+              ''
+            end
+          end
+
+          # Used to group examples for aggregation. `aggregate_failures`
+          # and `aggregate_failures: true` metadata are not taken in
+          # consideration, as it is dynamically set basing on cofiguration.
+          # If `aggregate_failures: false` is set on the example, it's
+          # preserved and is treated as regular metadata.
+          def metadata_without_aggregate_failures(example)
+            metadata = example_metadata(example) || []
+
+            symbols = metadata_symbols_without_aggregate_failures(metadata)
+            pairs = metadata_pairs_without_aggegate_failures(metadata)
+
+            [*symbols, pairs].flatten.compact
+          end
+
+          def example_metadata(example)
+            example.send_node.arguments
+          end
+
+          def metadata_symbols_without_aggregate_failures(metadata)
+            metadata
+              .select(&:sym_type?)
+              .reject { |item| item.value == :aggregate_failures }
+          end
+
+          def metadata_pairs_without_aggegate_failures(metadata)
+            map = metadata.find(&:hash_type?)
+            pairs = map&.pairs || []
+            pairs.reject do |pair|
+              pair.key.value == :aggregate_failures && pair.value.true_type?
+            end
+          end
+
+          def add_aggregate_failures_metadata?
+            cop_config.fetch('AddAggregateFailuresMetadata', false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/aggregate_examples/node_matchers.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'language'
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < ::RuboCop::Cop::Cop
+        # @internal
+        #   Node matchers and searchers.
+        module NodeMatchers
+          extend RuboCop::NodePattern::Macros
+          include Language
+
+          private
+
+          def_node_matcher :example_group_with_several_examples, <<-PATTERN
+            (block
+              #{ExampleGroups::ALL.send_pattern}
+              _
+              (begin $...)
+            )
+          PATTERN
+
+          def example_method?(method_name)
+            %i[it specify example scenario].include?(method_name)
+          end
+
+          # Matches examples with:
+          # - expectation statements exclusively
+          # - no title (e.g. `it('jumps over the lazy dog')`)
+          # - no HEREDOC
+          def_node_matcher :example_for_autocorrect?, <<-PATTERN
+            [
+              #example_with_expectations_only?
+              !#example_has_title?
+              !#contains_heredoc?
+            ]
+          PATTERN
+
+          def_node_matcher :example_with_expectations_only?, <<-PATTERN
+            (block #{Examples::EXAMPLES.send_pattern} _
+              { #single_expectation? (begin #single_expectation?+) }
+            )
+          PATTERN
+
+          # Matches the example with a title (e.g. `it('is valid')`)
+          def_node_matcher :example_has_title?, <<-PATTERN
+            (block
+              (send nil? #example_method? str ...)
+              ...
+            )
+          PATTERN
+
+          # Searches for HEREDOC in examples. It can be tricky to aggregate,
+          # especially when interleaved with parenthesis or curly braces.
+          def contains_heredoc?(node)
+            node.each_descendant(:str, :xstr, :dstr).any?(&:heredoc?)
+          end
+
+          def_node_matcher :subject_with_no_args?, <<-PATTERN
+            (send _ _)
+          PATTERN
+
+          def_node_matcher :expectation?, <<-PATTERN
+            {
+              (send nil? {:is_expected :are_expected})
+              (send nil? :expect #subject_with_no_args?)
+            }
+          PATTERN
+
+          def_node_matcher :single_expectation?, <<-PATTERN
+            (send #expectation? #{Runners::ALL.node_pattern_union} _)
+          PATTERN
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative 'aggregate_examples/matchers_with_side_effects'
+require_relative 'aggregate_examples/metadata_helpers'
+require_relative 'aggregate_examples/line_range_helpers'
+require_relative 'aggregate_examples/node_matchers'
+
+# This is shamelessly borrowed from test-prof
+# https://github.com/test-prof/test-prof/blob/02d8f355c158fb021e58ff1327d624a8299762b6/lib/test_prof/cops/rspec/aggregate_examples.rb
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if example groups contain two or more aggregatable examples.
+      #
+      # @see https://github.com/rubocop-hq/rspec-style-guide#expectation-per-example
+      #
+      # This cop is primarily for reducing the cost of repeated expensive
+      # context initialization.
+      #
+      # @example
+      #
+      #   # bad
+      #   describe do
+      #     it do
+      #       expect(number).to be_positive
+      #       expect(number).to be_odd
+      #     end
+      #
+      #     it { is_expected.to be_prime }
+      #   end
+      #
+      #   # good
+      #   describe do
+      #     it do
+      #       expect(number).to be_positive
+      #       expect(number).to be_odd
+      #       is_expected.to be_prime
+      #     end
+      #   end
+      #
+      #   # fair - subject has side effects
+      #   describe do
+      #     it do
+      #       expect(multiply_by(2)).to be_multiple_of(2)
+      #     end
+      #
+      #     it do
+      #       expect(multiply_by(3)).to be_multiple_of(3)
+      #     end
+      #   end
+      #
+      # Block expectation syntax is deliberately not supported due to:
+      #
+      # 1. `subject { -> { ... } }` syntax being hard to detect, e.g. the
+      #    following looks like an example with non-block syntax, but it might
+      #    be, depending on how the subject is defined:
+      #
+      #        it { is_expected.to do_something }
+      #
+      #    If the subject is defined in a `shared_context`, it's impossible to
+      #    detect that at all.
+      #
+      # 2. Aggregation should use composition with an `.and`. Also, aggregation
+      #    of the `not_to` expectations is barely possible when a matcher
+      #    doesn't provide a negated variant.
+      #
+      # 3. Aggregation of block syntax with non-block syntax should be in a
+      #    specific order.
+      #
+      # RSpec [comes with an `aggregate_failures` helper](https://relishapp.com/rspec/rspec-expectations/docs/aggregating-failures)
+      # not to fail the example on first unmet expectation that might come
+      # handy with aggregated examples.
+      # It can be [used in metadata form](https://relishapp.com/rspec/rspec-core/docs/expectation-framework-integration/aggregating-failures#use-%60:aggregate-failures%60-metadata),
+      # or [enabled globally](https://relishapp.com/rspec/rspec-core/docs/expectation-framework-integration/aggregating-failures#enable-failure-aggregation-globally-using-%60define-derived-metadata%60).
+      #
+      # @example Globally enable `aggregate_failures`
+      #
+      #   # spec/spec_helper.rb
+      #   config.define_derived_metadata do |metadata|
+      #     unless metadata.key?(:aggregate_failures)
+      #       metadata[:aggregate_failures] = true
+      #     end
+      #   end
+      #
+      # To match the style being used in the spec suite, AggregateExamples
+      # can be configured to add `:aggregate_failures` metadata to the
+      # example or not. The option not to add metadata can be also used
+      # when it's not desired to make expectations after previously failed
+      # ones, commonly known as fail-fast.
+      #
+      # The terms "aggregate examples" and "aggregate failures" not to be
+      # confused. The former stands for putting several expectations to
+      # a single example. The latter means to run all the expectations in
+      # the example instead of aborting on the first one.
+      #
+      # @example AddAggregateFailuresMetadata: true (default)
+      #
+      #   # Metadata set using a symbol
+      #   it(:aggregate_failures) do
+      #     expect(number).to be_positive
+      #     expect(number).to be_odd
+      #   end
+      #
+      # @example AddAggregateFailuresMetadata: false
+      #
+      #   it do
+      #     expect(number).to be_positive
+      #     expect(number).to be_odd
+      #   end
+      #
+      class AggregateExamples < ::RuboCop::Cop::Cop
+        include LineRangeHelpers
+        include MetadataHelpers
+        include NodeMatchers
+
+        # Methods from the following modules override and extend methods of this
+        # class, extracting specific behavior.
+        prepend MatchersWithSideEffects
+
+        MSG = 'Aggregate with the example at line %d.'
+
+        def on_block(node)
+          example_group_with_several_examples(node) do |all_examples|
+            example_clusters(all_examples).each_value do |examples|
+              examples[1..].each do |example|
+                add_offense(example,
+                            location: :expression,
+                            message: message_for(example, examples[0]))
+              end
+            end
+          end
+        end
+
+        def autocorrect(example_node)
+          clusters = example_clusters_for_autocorrect(example_node)
+          return if clusters.empty?
+
+          lambda do |corrector|
+            clusters.each do |metadata, examples|
+              range = range_for_replace(examples)
+              replacement = aggregated_example(examples, metadata)
+              corrector.replace(range, replacement)
+              examples[1..].map { |example| drop_example(corrector, example) }
+            end
+          end
+        end
+
+        private
+
+        # Clusters of examples in the same example group, on the same nesting
+        # level that can be aggregated.
+        def example_clusters(all_examples)
+          all_examples
+            .select { |example| example_with_expectations_only?(example) }
+            .group_by { |example| metadata_without_aggregate_failures(example) }
+            .select { |_, examples| examples.count > 1 }
+        end
+
+        # Clusters of examples that can be aggregated without losing any
+        # information (e.g. metadata or docstrings)
+        def example_clusters_for_autocorrect(example_node)
+          examples_in_group = example_node.parent.each_child_node(:block)
+            .select { |example| example_for_autocorrect?(example) }
+          example_clusters(examples_in_group)
+        end
+
+        def message_for(_example, first_example)
+          format(MSG, first_example.loc.line)
+        end
+
+        def drop_example(corrector, example)
+          aggregated_range = range_by_whole_lines(example.source_range,
+                                                  include_final_newline: true)
+          corrector.remove(aggregated_range)
+        end
+
+        def aggregated_example(examples, metadata)
+          base_indent = ' ' * examples.first.source_range.column
+          metadata = metadata_for_aggregated_example(metadata)
+          [
+            "#{base_indent}it#{metadata} do",
+            *examples.map { |example| transform_body(example, base_indent) },
+            "#{base_indent}end\n"
+          ].join("\n")
+        end
+
+        # Extracts and transforms the body, keeping proper indentation.
+        def transform_body(node, base_indent)
+          "#{base_indent}  #{new_body(node)}"
+        end
+
+        def new_body(node)
+          node.body.source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+
+module RuboCop
+  module Cop
+    module RSpec
+      module MultipleExpectationsAutoCorrect
+        def self.prepended(base)
+          base.extend(AutoCorrector)
+        end
+
+        private
+
+        def flag_example(node, expectation_count:)
+          add_offense(
+            node.send_node,
+            message: format(
+              MultipleExpectations::MSG,
+              total: expectation_count,
+              max: max_expectations
+            )
+          ) do |corrector|
+            autocorrect(node, corrector)
+          end
+        end
+
+        def autocorrect(node, corrector)
+          if (args = node.children.first.arguments.first)
+            corrector.insert_after(args, ', :aggregate_failures')
+          else
+            corrector.insert_after(node.children.first, ' :aggregate_failures')
+          end
+        end
+      end
+    end
+  end
+end
+
+RuboCop::Cop::RSpec::MultipleExpectations
+  .prepend(RuboCop::Cop::RSpec::MultipleExpectationsAutoCorrect)

data/lib/rubocop/cop/sidekiq/no_nil_return.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Ensure workers avoid returning early
+      #
+      # # bad
+      # def perform
+      #   return if condition
+      #   ...
+      # end
+      #
+      # # good
+      # def perform
+      #   # TDB, idea would be `raise SilentError if condition`
+      # end
+
+      class NoNilReturn < Base
+        MSG = 'Avoid using early nil return in workers.'
+
+        def on_return(node)
+          add_offense(node) if node.arguments.first&.nil_type? || node.arguments.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/petal/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Petal
-    VERSION = '1.1.2'
+    VERSION = '1.3.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-petal
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Jean-Francis Bastien
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-30 00:00:00.000000000 Z
+date: 2024-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -16,57 +16,71 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.50'
+        version: '1.59'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.50'
+        version: '1.59'
+- !ruby/object:Gem::Dependency
+  name: rubocop-factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.24'
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '1.20'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '1.20'
 - !ruby/object:Gem::Dependency
   name: rubocop-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.19'
+        version: '2.23'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.19'
+        version: '2.23'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.17'
+        version: '2.25'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.17'
-description: 
+        version: '2.25'
+description:
 email:
 - jfbastien@petalmd.com
 executables: []
@@ -80,6 +94,7 @@ files:
 - config/base.yml
 - config/default.yml
 - lib/rubocop-petal.rb
+- lib/rubocop/cop/chewy/field_type.rb
 - lib/rubocop/cop/chewy/reset_on_type.rb
 - lib/rubocop/cop/grape/helpers_include_module.rb
 - lib/rubocop/cop/grape/prefer_namespace.rb
@@ -88,15 +103,26 @@ files:
 - lib/rubocop/cop/migration/change_table_references.rb
 - lib/rubocop/cop/migration/foreign_key_option.rb
 - lib/rubocop/cop/migration/schema_statements_methods.rb
+- lib/rubocop/cop/migration/standalone_add_reference.rb
 - lib/rubocop/cop/performance/snif.rb
 - lib/rubocop/cop/petal_cops.rb
+- lib/rubocop/cop/rails/destroy_all_bang.rb
 - lib/rubocop/cop/rails/enum_prefix.rb
+- lib/rubocop/cop/rails/enum_starting_value.rb
 - lib/rubocop/cop/rails/risky_activerecord_invocation.rb
+- lib/rubocop/cop/rspec/aggregate_examples.rb
+- lib/rubocop/cop/rspec/aggregate_examples/language.rb
+- lib/rubocop/cop/rspec/aggregate_examples/line_range_helpers.rb
+- lib/rubocop/cop/rspec/aggregate_examples/matchers_with_side_effects.rb
+- lib/rubocop/cop/rspec/aggregate_examples/metadata_helpers.rb
+- lib/rubocop/cop/rspec/aggregate_examples/node_matchers.rb
 - lib/rubocop/cop/rspec/authenticated_as.rb
 - lib/rubocop/cop/rspec/create_list_max.rb
 - lib/rubocop/cop/rspec/json_response.rb
+- lib/rubocop/cop/rspec/multiple_expectations_auto_correct.rb
 - lib/rubocop/cop/rspec/sidekiq_inline.rb
 - lib/rubocop/cop/rspec/stub_products.rb
+- lib/rubocop/cop/sidekiq/no_nil_return.rb
 - lib/rubocop/petal.rb
 - lib/rubocop/petal/inject.rb
 - lib/rubocop/petal/version.rb
@@ -109,7 +135,7 @@ metadata:
   source_code_uri: https://github.com/petalmd/rubocop-petal
   bug_tracker_uri: https://github.com/petalmd/rubocop-petal/issues
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -117,15 +143,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key: 
+rubygems_version: 3.4.18
+signing_key:
 specification_version: 4
 summary: Petal custom cops
 test_files: []