rubocop-petal 1.8.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf2f66c07fd9f7e2d26db32b9ab5a5fc704293066bf6e8519b6fdec8cec71128
-  data.tar.gz: 3f4a7fef3bde079552b9bcffc43665a93422d3bf4dacda37a754540787dd4773
+  metadata.gz: 10f81655924fecdd2195281a71d19602efadfc7a9a60e7a9f005136c969aa45f
+  data.tar.gz: d5e0bab2b887cec6b46ed1ac96993cd18fe0c485f0723425288bb9c80c57f396
 SHA512:
-  metadata.gz: 70fe73e240f643f554767029a2cffbb4e298b80706c823c2dda8eccb2470da549aba51847241e68f7871aedabd6a0702f37ed97ed771c2aa703aabe6c03c9b93
-  data.tar.gz: 77d30ff3b03bf663b6546f3a243a90cde664a854467879e0ef3d47f2856f860eddec31ac39a8f9b723450e642f3f9f2593c1ad1cfae59baa5fea8e1b3e67e3e6
+  metadata.gz: 0f54b691eb3fa5512d745e425494ce785dec5f74deccc101c85e7214eb2b4d227619f987347e2ab29a7dc5d0d509b52bfdaa6e44cdf297d440b76a21a91dd4dd
+  data.tar.gz: 210f323604d3ceae5db556afd7aa7f689b4c830d2886d7994030586c0726f5e6f7b7e05314dc49f0d39ec887142b857dd0ce9cbe22712dc3fc8a855ae35ac084

data/config/default.yml

@@ -15,6 +15,12 @@ Grape/PreferNamespace:
   Include:
     - app/api/**/*
 
+Migration/AlterAfterCreateTable:
+  Description: 'Prefer defining new table changes inside the create_table block.'
+  Enabled: true
+  Include:
+    - db/migrate/**
+
 Migration/AlwaysBulkChangeTable:
   Description: 'Suggest to always use `bulk: true` when using `change_table`.'
   Enabled: true
@@ -59,6 +65,12 @@ RSpec/AggregateExamples:
     - validate_inclusion_of
     - validates_exclusion_of
 
+RSpec/AggregateFailuresTag:
+  Description: 'Checks that the `:aggregate_failures` tag is only used on examples, not on example groups.'
+  Enabled: true
+  Include:
+    - spec/**/*
+
 RSpec/ChewyStrategy:
   Description: 'Prevent using Chewy strategy in tests.'
   Enabled: true
@@ -156,12 +168,14 @@ Sidekiq/KeywordArguments:
   Enabled: true
   Include:
     - app/workers/**/*
+    - app/jobs/**/*
 
 Sidekiq/NoNilReturn:
   Description: 'Prevent early nil return in workers'
   Enabled: false
   Include:
     - app/workers/**/*
+    - app/jobs/**/*
 
 Sidekiq/PerformInline:
   Description: 'Suggest to use `perform_inline` instead of `new.perform` for Sidekiq workers.'
@@ -171,3 +185,26 @@ Sidekiq/SymbolArgument:
   Description: "Prevent passing keywords arguments in worker's perform method"
   Enabled: true
   SafeAutoCorrect: false
+
+Sidekiq/PreferJob:
+  Description: 'Prefer `Sidekiq::Job` over `Sidekiq::Worker`.'
+  Enabled: true
+  StyleGuide: https://github.com/sidekiq/sidekiq/wiki/Best-Practices#4-use-precise-terminology
+  Include:
+    - app/workers/**/*
+    - app/jobs/**/*
+
+Sidekiq/JobNaming:
+  Description: 'Job class name should end with `Job` instead of `Worker`.'
+  Enabled: true
+  StyleGuide: https://github.com/sidekiq/sidekiq/wiki/Best-Practices#4-use-precise-terminology
+  Include:
+    - app/workers/**/*
+    - app/jobs/**/*
+
+Sidekiq/JobLocation:
+  Description: 'Job class with `Job` suffix should be placed in `app/jobs` directory instead of `app/workers`.'
+  Enabled: true
+  StyleGuide: https://github.com/sidekiq/sidekiq/wiki/Best-Practices#4-use-precise-terminology
+  Include:
+    - app/workers/**/*

data/lib/rubocop/cop/grape/unnecessary_namespace.rb

@@ -18,7 +18,16 @@ module RuboCop
               'Specify endpoint name with an argument: `get :some_path`.'
         HTTP_ACTIONS = Set.new(%i[get head put post patch delete])
         GRAPE_NAMESPACE_ALIAS = Set.new(%i[namespace resource resources])
-        METHOD_JUSTIFY_NAMESPACE = Set.new(%i[route_param namespaces resource resources version])
+        METHOD_JUSTIFY_NAMESPACE = Set.new(%i[route_param
+                                              namespaces
+                                              resource
+                                              resources
+                                              version
+                                              before
+                                              after
+                                              finally
+                                              after_validation
+                                              before_validation])
 
         def_node_matcher :namespace?, <<~PATTERN
           (send nil? GRAPE_NAMESPACE_ALIAS ({sym | str} _))

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Prefer defining table changes inside the create_table block instead of
+      # altering the table immediately after creating it.
+      #
+      # @example
+      #   # bad
+      #   create_table :users do |t|
+      #     t.string :email
+      #   end
+      #
+      #   add_index :users, :email, unique: true
+      #
+      #   # good
+      #   create_table :users do |t|
+      #     t.string :email
+      #     t.index :email, unique: true
+      #   end
+      class AlterAfterCreateTable < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer defining new table changes inside the create_table block.'
+
+        ALTER_METHODS = (
+          Rails::BulkChangeTable::COMBINABLE_ALTER_METHODS +
+          Rails::BulkChangeTable::MYSQL_COMBINABLE_ALTER_METHODS +
+          Rails::BulkChangeTable::POSTGRESQL_COMBINABLE_ALTER_METHODS +
+          Rails::BulkChangeTable::POSTGRESQL_COMBINABLE_ALTER_METHODS_SINCE_6_1
+        ).uniq.freeze
+
+        RESTRICT_ON_SEND = ALTER_METHODS.freeze
+
+        def on_block(node)
+          return unless node.send_node&.command?(:create_table)
+          return unless (alter_node = alter_node_after_create_table(node))
+          return unless same_table?(node.send_node, alter_node)
+
+          add_alter_offense(node, alter_node)
+        end
+
+        private
+
+        def alter_node_after_create_table(create_table_node)
+          siblings = sibling_nodes(create_table_node)
+          index = siblings.index(create_table_node)
+          return unless index
+
+          alter_node = siblings[index + 1]
+          return unless alter_node&.send_type?
+          return unless ALTER_METHODS.include?(alter_node.method_name)
+          return unless alter_node.receiver.nil?
+
+          alter_node
+        end
+
+        def sibling_nodes(node)
+          parent = node.parent
+          return parent.children if parent&.begin_type?
+
+          []
+        end
+
+        def same_table?(create_table_node, alter_node)
+          create_table_argument = create_table_node.first_argument
+          alter_table_argument = alter_node.first_argument
+          return false unless create_table_argument && alter_table_argument
+
+          if create_table_argument.is_a?(RuboCop::AST::BasicLiteralNode) &&
+             alter_table_argument.is_a?(RuboCop::AST::BasicLiteralNode)
+            literal_value(create_table_argument) == literal_value(alter_table_argument)
+          else
+            create_table_argument.source == alter_table_argument.source
+          end
+        end
+
+        def literal_value(node)
+          return unless node.is_a?(RuboCop::AST::BasicLiteralNode)
+
+          node.value.to_s
+        end
+
+        def add_alter_offense(create_table_node, alter_node)
+          replacement = replacement_for(create_table_node, alter_node)
+
+          add_offense(alter_node.loc.selector) do |corrector|
+            next unless replacement
+
+            end_line_range = processed_source.buffer.line_range(create_table_node.loc.end.line)
+            corrector.insert_before(end_line_range, "#{replacement}\n")
+            corrector.remove(range_by_whole_lines(alter_node.source_range, include_final_newline: true))
+          end
+        end
+
+        def replacement_for(create_table_node, alter_node)
+          block_variable = create_table_node.arguments.first&.source
+          return unless block_variable
+
+          case alter_node.method_name
+            when :add_index
+              replacement_for_add_index(block_variable, alter_node)
+            when :add_column
+              replacement_for_add_column(block_variable, alter_node)
+            when :add_timestamps
+              replacement_for_add_timestamps(block_variable, alter_node)
+          end
+        end
+
+        def replacement_for_add_index(block_variable, node)
+          "#{indentation(node)}#{block_variable}.index #{arguments_after_table(node)}"
+        end
+
+        def replacement_for_add_column(block_variable, node)
+          column_node, type_node = node.arguments[1, 2]
+          return unless column_node && type_node
+          return unless type_node.sym_type?
+
+          extra_arguments = node.arguments[3..].map(&:source)
+          arguments = [column_node.source, *extra_arguments].join(', ')
+
+          "#{indentation(node)}#{block_variable}.#{type_node.value} #{arguments}"
+        end
+
+        def replacement_for_add_timestamps(block_variable, node)
+          arguments = arguments_after_table(node)
+          method_call = "#{block_variable}.timestamps"
+          method_call = "#{method_call} #{arguments}" unless arguments.empty?
+
+          "#{indentation(node)}#{method_call}"
+        end
+
+        def arguments_after_table(node)
+          node.arguments[1..].map(&:source).join(', ')
+        end
+
+        def indentation(alter_node)
+          ' ' * (alter_node.loc.column + 2)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that the `:aggregate_failures` tag is only used on examples,
+      # not on example groups.
+      #
+      # The `:aggregate_failures` tag only works on individual examples (`it`, `specify`, etc.),
+      # not on example groups (`describe`, `context`, etc.).
+      #
+      # @example
+      #   # bad
+      #   describe '#enabled?', :aggregate_failures do
+      #     # ...
+      #   end
+      #
+      #   context 'when enabled', :aggregate_failures do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   it 'returns true', :aggregate_failures do
+      #     # ...
+      #   end
+      #
+      #   specify 'the behavior', :aggregate_failures do
+      #     # ...
+      #   end
+      #
+      class AggregateFailuresTag < Base
+        MSG = 'The `:aggregate_failures` tag should only be used on examples, not on example groups.'
+
+        EXAMPLE_METHODS = %i[
+          it
+          specify
+          example
+          scenario
+          its
+          fit
+          fspecify
+          fexample
+          fscenario
+          focus
+          xit
+          xspecify
+          xexample
+          xscenario
+          skip
+          pending
+        ].freeze
+
+        RSPEC_METHODS = %i[
+          describe
+          context
+          feature
+          example_group
+          xdescribe
+          fdescribe
+          it
+          specify
+          example
+          scenario
+          its
+          fit
+          fspecify
+          fexample
+          fscenario
+          focus
+          xit
+          xspecify
+          xexample
+          xscenario
+          skip
+          pending
+        ].freeze
+
+        def on_block(node)
+          return unless rspec_block?(node)
+          return unless aggregate_failures_tag?(node)
+          return if example_method?(node)
+
+          # Create a range that includes the method call up to and including the 'do' keyword
+          send_node = node.send_node
+          range = send_node.source_range.join(node.loc.begin)
+          add_offense(range)
+        end
+
+        private
+
+        def rspec_block?(node)
+          send_node = node.send_node
+          return false unless send_node
+          return false unless send_node.send_type?
+
+          RSPEC_METHODS.include?(send_node.method_name)
+        end
+
+        def example_method?(node)
+          send_node = node.send_node
+          return false unless send_node
+
+          EXAMPLE_METHODS.include?(send_node.method_name)
+        end
+
+        def aggregate_failures_tag?(node)
+          send_node = node.send_node
+          return false unless send_node
+
+          send_node.arguments.any? do |arg|
+            if arg.sym_type? && arg.value == :aggregate_failures
+              true
+            elsif arg.hash_type?
+              arg.pairs.any? { |pair| pair.key.sym_type? && pair.key.value == :aggregate_failures }
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module RuboCop
       module Helpers
         NODE_MATCHERS = lambda do
           def_node_matcher :sidekiq_include?, <<~PATTERN
-            (send nil? :include (const (const nil? :Sidekiq) :Worker))
+            (send nil? :include (const (const {nil? cbase} :Sidekiq) {:Worker :Job}))
           PATTERN
 
           def_node_matcher :includes_sidekiq?, <<~PATTERN

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # This cop checks that Sidekiq job classes with "Job" suffix are placed in the
+      # `app/jobs` directory instead of `app/workers` directory.
+      # This follows the modern Sidekiq convention where jobs should be organized
+      # in the appropriate directory structure.
+      #
+      # @example
+      #   # bad - Job class in app/workers directory
+      #   # app/workers/my_job.rb
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      #   # good - Job class in app/jobs directory
+      #   # app/jobs/my_job.rb
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      #   # good - Worker class can stay in app/workers (though not recommended)
+      #   # app/workers/my_worker.rb
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #   end
+      class JobLocation < Base
+        include Helpers
+
+        MSG = 'Job class with `Job` suffix should be placed in `app/jobs` directory instead of `app/workers`.'
+
+        def on_class(node)
+          return unless sidekiq_worker?(node)
+
+          class_name = extract_class_name(node)
+          return unless class_name
+          return unless class_name.end_with?('Job')
+
+          file_path = processed_source.buffer.name
+          return unless file_path.include?('app/workers/')
+
+          add_offense(node.children.first, message: MSG)
+        end
+
+        private
+
+        def extract_class_name(node)
+          name_node = node.children.first
+          return unless name_node&.const_type?
+
+          # Get the last part of the constant name (e.g., "EmailJob" from "MyApp::EmailJob")
+          name_node.children.last.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # This cop checks that Sidekiq job class names end with "Job" instead of "Worker".
+      # Since Sidekiq 6.3, it is best practice to use "Job" terminology over "Worker".
+      #
+      # @example
+      #   # bad
+      #   class MyWorker
+      #     include Sidekiq::Job
+      #   end
+      #
+      #   class ProcessDataWorker
+      #     include Sidekiq::Worker
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      #   class ProcessDataJob
+      #     include Sidekiq::Job
+      #   end
+      class JobNaming < Base
+        include Helpers
+
+        MSG = 'Job class name should end with `Job` instead of `Worker`.'
+
+        def_node_matcher :class_name, <<~PATTERN
+          (class (const _ $_) ...)
+        PATTERN
+
+        def on_class(node)
+          return unless sidekiq_worker?(node)
+
+          class_name = extract_class_name(node)
+          return unless class_name
+          return unless class_name.end_with?('Worker')
+
+          add_offense(node.children.first, message: MSG)
+        end
+
+        private
+
+        def extract_class_name(node)
+          name_node = node.children.first
+          return unless name_node&.const_type?
+
+          # Get the last part of the constant name (e.g., "EmailWorker" from "MyApp::EmailWorker")
+          name_node.children.last.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # This cop checks for the use of `Sidekiq::Worker` and suggests using `Sidekiq::Job` instead.
+      # Since Sidekiq 6.3, it is best practice to use `Sidekiq::Job` over `Sidekiq::Worker`.
+      #
+      # @example
+      #   # bad
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      class PreferJob < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `Sidekiq::Job` over `Sidekiq::Worker`.'
+
+        def_node_matcher :sidekiq_worker_include?, <<~PATTERN
+          (send nil? :include (const (const {nil? cbase} :Sidekiq) :Worker))
+        PATTERN
+
+        def on_send(node)
+          return unless sidekiq_worker_include?(node)
+
+          add_offense(node, message: MSG) do |corrector|
+            corrector.replace(node.arguments.first, 'Sidekiq::Job')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/petal/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Petal
-    VERSION = '1.8.0'
+    VERSION = '1.10.0'
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-petal
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Jean-Francis Bastien
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lint_roller
@@ -108,7 +107,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.31'
-description:
 email:
 - jfbastien@petalmd.com
 executables: []
@@ -128,6 +126,7 @@ files:
 - lib/rubocop/cop/grape/helpers_include_module.rb
 - lib/rubocop/cop/grape/prefer_namespace.rb
 - lib/rubocop/cop/grape/unnecessary_namespace.rb
+- lib/rubocop/cop/migration/alter_after_create_table.rb
 - lib/rubocop/cop/migration/always_bulk_change_table.rb
 - lib/rubocop/cop/migration/change_table_references.rb
 - lib/rubocop/cop/migration/foreign_key_option.rb
@@ -145,6 +144,7 @@ files:
 - 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/aggregate_failures_tag.rb
 - lib/rubocop/cop/rspec/chewy_strategy.rb
 - lib/rubocop/cop/rspec/create_list_max.rb
 - lib/rubocop/cop/rspec/json_response.rb
@@ -155,9 +155,12 @@ files:
 - lib/rubocop/cop/sidekiq/const_argument.rb
 - lib/rubocop/cop/sidekiq/date_time_argument.rb
 - lib/rubocop/cop/sidekiq/helpers.rb
+- lib/rubocop/cop/sidekiq/job_location.rb
+- lib/rubocop/cop/sidekiq/job_naming.rb
 - lib/rubocop/cop/sidekiq/keyword_arguments.rb
 - lib/rubocop/cop/sidekiq/no_nil_return.rb
 - lib/rubocop/cop/sidekiq/perform_inline.rb
+- lib/rubocop/cop/sidekiq/prefer_job.rb
 - lib/rubocop/cop/sidekiq/symbol_argument.rb
 - lib/rubocop/petal.rb
 - lib/rubocop/petal/plugin.rb
@@ -172,7 +175,6 @@ metadata:
   bug_tracker_uri: https://github.com/petalmd/rubocop-petal/issues
   rubygems_mfa_required: 'true'
   default_lint_roller_plugin: RuboCop::Petal::Plugin
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -187,8 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Petal custom cops
 test_files: []