rubocop-petal 1.3.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e00aaceb476db83ee7becc110d01e4fc67b0e7fbdea207aceee51465f6314de6
-  data.tar.gz: 0033f05f11d00e7b32798cb2aa77ad8c9158486676d69d0c489d21a6dac217d2
+  metadata.gz: cdc12661793d2fbaa5d5634b86c23eb3e249a884ec4902406d66d969565fccd7
+  data.tar.gz: 8b1b59059300e38b056fab5b4c1d342ae3bf61dcd0db1204f140586c15dc889a
 SHA512:
-  metadata.gz: 66b77b9959c0fcdcfed06a5badcef6dd6dcc3c70383391ff63dea069725a964ba178484a60e747c131cf08cbbf167efce4b7691cf00f5f40e7f34a49ffbc1fab
-  data.tar.gz: 4348a41527e5c4374b8e610c72cab2e855f484952e3bc4a98e4a86e7ad2a650c935733919d2e3610c81936b0eea716d46eb88d8171dc3980e3bf045ec1a3b2f4
+  metadata.gz: 5c1494de93b6053ecac07431001234072212e9f62f9130b3dcc6ccefd3218cb3b454e5ace6de2c1e0d6d6aa91adf651d5454ebcfbca346b707579d45e855e77f
+  data.tar.gz: adb3d03f9419b9629ae7db9b7b1b4e811ce9d27a6a3b209f6ad6feaa4ca7edce47da7c698d3e9074cf25c3d452f022a2abebf0c80bb9b1b9764178614a571133

data/config/base.yml

@@ -78,6 +78,8 @@ RSpec/StubbedMock:
 RSpec/DescribeClass:
   Exclude:
     - spec/integration/**/*.rb
+Rails/Date:
+  AllowToTime: false
 Rails/SaveBang:
   Enabled: true
 Rails/NotNullColumn:

data/config/default.yml

@@ -4,6 +4,10 @@ Chewy/FieldType:
   Include:
     - app/chewy/**/*
 
+Chewy/UpdateIndexArgument:
+  Description: 'Prevent single expression in update_index block.'
+  Enabled: true
+
 Grape/PreferNamespace:
   Description: 'Prevent usage of namespace aliases.'
   Enabled: true
@@ -55,12 +59,6 @@ RSpec/AggregateExamples:
     - validate_inclusion_of
     - validates_exclusion_of
 
-RSpec/AuthenticatedAs:
-  Description: 'Suggest to use authenticated_as instead of legacy api_key.'
-  Enabled: true
-  Include:
-    - spec/api/**/*_spec.rb
-
 RSpec/CreateListMax:
   Description: 'Prevent creating to most records with `FactoryBot.create_list`.'
   Enabled: true
@@ -132,6 +130,30 @@ Performance/Snif:
   Description: 'Prevent snif in favor of detect'
   Enabled: true
 
+Sidekiq/ConstArgument:
+  Description: "Prevent passing constant like Class as arguments in worker's perform method"
+  Enabled: true
+
+Sidekiq/DateTimeArgument:
+  Description: "Prevent passing Date/Time arguments in worker's perform method"
+  Enabled: true
+
+Sidekiq/KeywordArguments:
+  Description: "Prevent define keywords arguments in worker's perform method"
+  Enabled: true
+  Include:
+    - app/workers/**/*
+
 Sidekiq/NoNilReturn:
   Description: 'Prevent early nil return in workers'
   Enabled: false
+  Include:
+    - app/workers/**/*
+
+Sidekiq/PerformInline:
+  Description: 'Suggest to use `perform_inline` instead of `new.perform` for Sidekiq workers.'
+  Enabled: true
+
+Sidekiq/SymbolArgument:
+  Description: "Prevent passing keywords arguments in worker's perform method"
+  Enabled: true

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Chewy
+      # This cop checks for the use of block with single expression in `update_index` method
+      # and suggests to use method symbol as second argument instead of block.
+      #
+      # # bad
+      # update_index('index_name') { self }
+      #
+      # # good
+      # update_index('index_name', :self)
+      #
+      class UpdateIndexArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Use method symbol as second argument instead of block.'
+
+        RESTRICT_ON_SEND = %i[update_index].freeze
+
+        # @!method block_with_single_expression?(node)
+        def_node_matcher :block_with_single_expression?, <<~PATTERN
+          (block
+            (send nil? :update_index (str _) $...)
+            (args)
+            $...)
+        PATTERN
+
+        def on_block(node)
+          block_with_single_expression?(node) do |existing_args, method_name|
+            return if method_name.last.children.compact.size > 1
+
+            method_name = method_name.first.source
+            add_offense(node.loc.expression) do |corrector|
+              corrector.replace(node.loc.expression, corrected_code(node, existing_args, method_name))
+            end
+          end
+        end
+
+        private
+
+        def corrected_code(node, existing_args, method_name)
+          method_call = node.children[0]
+          index_name = method_call.children[2].source
+
+          if existing_args.any?
+            "update_index(#{index_name}, :#{method_name}, #{existing_args.map(&:source).join(', ')})"
+          else
+            "update_index(#{index_name}, :#{method_name})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+# credit: https://github.com/dvandersluis/rubocop-sidekiq/blob/master/lib/rubocop/cop/sidekiq/const_argument.rb
+module RuboCop
+  module Cop
+    module Sidekiq
+      # This cop checks for Sidekiq worker perform arguments that look like classes or modules.
+      # These cannot be serialized for Redis, and should not be used with Sidekiq.
+      #
+      # Constants other than classes/modules are not flagged by this cop.
+      #
+      # @example
+      #   # bad
+      #   MyWorker.perform_async(MyClass)
+      #   MyWorker.perform_async(MyModule)
+      #   MyWorker.perform_async(Namespace::Class)
+      #
+      #   # good
+      #   MyWorker.perform_async(MY_CONSTANT)
+      #   MyWorker.perform_async(MyClass::MY_CONSTANT)
+      class ConstArgument < Base
+        CONSTANT_NAME = /\A[A-Z0-9_]+\z/.freeze
+
+        include Helpers
+
+        MSG = 'Objects are not Sidekiq-serializable.'
+        MSG_SELF = '`self` is not Sidekiq-serializable.'
+
+        def_node_matcher :initializer?, <<~PATTERN
+          (send const :new)
+        PATTERN
+
+        def_node_matcher :constant?, <<~PATTERN
+          (const _ _)
+        PATTERN
+
+        def_node_matcher :const_argument?, <<~PATTERN
+          {#initializer? #constant? self}
+        PATTERN
+
+        def on_send(node)
+          sidekiq_arguments(node).each do |arg|
+            next unless const_argument?(arg)
+            next if non_class_constant?(arg)
+
+            add_offense(arg, message: arg.self_type? ? MSG_SELF : MSG)
+          end
+        end
+
+        private
+
+        def non_class_constant?(arg)
+          arg.const_type? && arg.children[1].to_s.match?(CONSTANT_NAME)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+# credit: https://github.com/dvandersluis/rubocop-sidekiq/blob/master/lib/rubocop/cop/sidekiq/date_time_argument.rb
+module RuboCop
+  module Cop
+    module Sidekiq
+      # This cop checks for date/time objects being passed as arguments to perform a Sidekiq
+      # worker. Dates, times, durations, and related classes cannot be serialized to Redis.
+      # Use an integer or string representation of the date/time instead.
+      #
+      # By default, this only allows `to_i` and `to_s` as valid, serializable methods for these
+      # classes. Use `AllowedMethods` to specify other allowed methods.
+      #
+      # @example
+      #   # bad
+      #   MyWorker.perform_async(Time.now)
+      #   MyWorker.perform_async(Date.today)
+      #   MyWorker.perform_async(DateTime.now)
+      #   MyWorker.perform_async(ActiveSupport::TimeWithZone.new)
+      #   MyWorker.perform_async(1.hour)
+      #   MyWorker.perform_async(1.hour.ago)
+      #
+      #   # good
+      #   MyWorker.perform_async(Time.now.to_i)
+      #   MyWorker.perform_async(Date.today.to_s)
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   MyWorker.perform_async(Time.now.mday)
+      #
+      # @example AllowedMethods: ['mday']
+      #   # good
+      #   MyWorker.perform_async(Time.now.mday)
+      #
+      class DateTimeArgument < ::RuboCop::Cop::Cop
+        DURATION_METHODS = %i[
+          second
+          seconds
+          minute
+          minutes
+          hour
+          hours
+          day
+          days
+          week
+          weeks
+          fortnight
+          fortnights
+        ].freeze
+
+        DURATION_TO_TIME_METHODS = %i[
+          from_now
+          since
+          after
+          ago
+          until
+          before
+        ].freeze
+
+        include Helpers
+
+        DURATION_MSG = 'Durations are not Sidekiq-serializable; use the integer instead.'
+        MSG = 'Date/Time objects are not Sidekiq-serializable; convert to integers or strings instead.'
+        ALLOWED_METHODS = %i[to_i to_s].freeze
+
+        def_node_matcher :rational_literal?, <<~PATTERN
+          (send
+            (int _) :/
+            (rational _))
+        PATTERN
+
+        def_node_matcher :duration?, <<~PATTERN
+          {
+            (send {int float rational #rational_literal?} #duration_method?)
+            (send (const (const _ :ActiveSupport) :Duration) ...)
+          }
+        PATTERN
+
+        def_node_matcher :date_time_send?, <<~PATTERN
+          $(send
+            `{
+              (const _ {:Date :DateTime :Time})
+              (const (const _ :ActiveSupport) :TimeWithZone)
+            }
+            ...
+          )
+        PATTERN
+
+        def_node_matcher :date_time_arg?, <<~PATTERN
+          { #duration? #date_time_send? (send `#duration? #duration_to_time_method?) }
+        PATTERN
+
+        def on_send(node)
+          sidekiq_arguments(node).each do |arg|
+            next unless date_time_arg?(arg)
+            next if node_approved?(arg)
+
+            # If the outer send (ie. the last method in the chain) is in the allowed method
+            # list, approve the node (so that sub chains aren't flagged).
+            if allowed_methods.include?(arg.method_name)
+              approve_node(arg)
+              next
+            end
+
+            add_offense(arg)
+          end
+        end
+
+        def allowed_methods
+          Array(cop_config['AllowedMethods']).concat(ALLOWED_METHODS).map(&:to_sym)
+        end
+
+        def duration_method?(sym)
+          DURATION_METHODS.include?(sym)
+        end
+
+        def duration_to_time_method?(sym)
+          DURATION_TO_TIME_METHODS.include?(sym)
+        end
+
+        def message(node)
+          return DURATION_MSG if duration?(node)
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# credit: https://github.com/dvandersluis/rubocop-sidekiq/blob/master/lib/rubocop/cop/helpers.rb
+module RuboCop
+  module Cop
+    module Sidekiq
+      module Helpers
+        NODE_MATCHERS = lambda do
+          def_node_matcher :sidekiq_include?, <<~PATTERN
+            (send nil? :include (const (const nil? :Sidekiq) :Worker))
+          PATTERN
+
+          def_node_matcher :includes_sidekiq?, <<~PATTERN
+            {
+              (begin <#sidekiq_include? ...>)
+              #sidekiq_include?
+            }
+          PATTERN
+
+          def_node_matcher :worker_class_def?, <<~PATTERN
+            (class _ _ #includes_sidekiq?)
+          PATTERN
+
+          def_node_matcher :worker_anon_class_def?, <<~PATTERN
+            (block (send (const nil? :Class) :new ...) _ #includes_sidekiq?)
+          PATTERN
+
+          def_node_matcher :worker_class_application_worker?, <<~PATTERN
+            (class _ (const {nil? cbase} :ApplicationWorker) ...)
+          PATTERN
+
+          def_node_matcher :worker_anon_class_application_worker_def?, <<~PATTERN
+            (block (send (const nil? :Class) :new (const {nil? cbase} :ApplicationWorker)) ...)
+          PATTERN
+
+          def_node_matcher :sidekiq_worker?, <<~PATTERN
+            {#worker_class_def? #worker_anon_class_def? #worker_class_application_worker? #worker_anon_class_application_worker_def?}
+          PATTERN
+
+          def_node_matcher :sidekiq_perform?, <<~PATTERN
+            (send const ${:perform_async :perform_in :perform_at} ...)
+          PATTERN
+        end
+
+        def self.included(klass)
+          klass.class_exec(&NODE_MATCHERS)
+        end
+
+        def in_sidekiq_worker?(node)
+          node.each_ancestor(:class, :block).detect { |anc| sidekiq_worker?(anc) }
+        end
+
+        def sidekiq_arguments(node)
+          return [] unless node.send_type? && (method_name = sidekiq_perform?(node))
+
+          # Drop the first argument for perform_at and perform_in
+          expand_arguments(method_name == :perform_async ? node.arguments : node.arguments[1..])
+        end
+
+        def expand_arguments(arguments)
+          arguments.flat_map do |argument|
+            if argument.array_type? || argument.hash_type?
+              expand_arguments(argument.values)
+            else
+              argument
+            end
+          end
+        end
+
+        def node_approved?(node)
+          @approved_nodes ||= []
+          @approved_nodes.any? { |r| within?(node.source_range, r) }
+        end
+        alias node_denied? node_approved?
+
+        def approve_node(node)
+          @approved_nodes ||= []
+          @approved_nodes << node.source_range
+        end
+        alias deny_node approve_node
+
+        def within?(inner, outer)
+          inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+# credit: https://github.com/dvandersluis/rubocop-sidekiq/blob/master/lib/rubocop/cop/sidekiq/keyword_arguments.rb
+module RuboCop
+  module Cop
+    module Sidekiq
+      # This cop checks for Sidekiq worker `perform` methods that use keyword args. Keyword args
+      # cannot be properly serialized to Redis and are thus not recommended. Use regular arguments
+      # instead.
+      #
+      # @example
+      #   # bad
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #
+      #     def perform(id:, keyword_with_default: false, **other_kwargs)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #
+      #     def perform(id, arg_with_default = false, *other_args)
+      #     end
+      #   end
+      class KeywordArguments < Base
+        include Helpers
+
+        MSG = "Keyword arguments are not allowed in a sidekiq worker's perform method."
+        KWARG_TYPES = %i[kwarg kwoptarg kwrestarg].freeze
+
+        def_node_matcher :perform_with_kwargs?, <<~PATTERN
+          (def :perform (args ... {kwarg kwoptarg kwrestarg}) ...)
+        PATTERN
+
+        def on_def(node)
+          return unless perform_with_kwargs?(node)
+          return unless in_sidekiq_worker?(node)
+
+          node.arguments.each do |arg|
+            next unless KWARG_TYPES.include?(arg.type)
+
+            add_offense(arg)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Suggest to use `perform_inline` instead of `new.perform` for Sidekiq workers.
+      #
+      # @bad
+      #   MyWorker.new.perform
+      #
+      # @good
+      #   MyWorker.perform_inline
+      #
+      class PerformInline < Base
+        extend AutoCorrector
+        MSG = 'Use `perform_inline` instead of `new.perform`'
+
+        RESTRICT_ON_SEND = %i[perform].freeze
+
+        # @!method new_perform?(node)
+        def_node_matcher :new_perform?, <<~PATTERN
+          (send (send _ :new) :perform ...)
+        PATTERN
+
+        def on_send(node)
+          return unless new_perform?(node)
+
+          new_perform_node = node.source_range.with(
+            begin_pos: node.receiver.receiver.source_range.end_pos + 1,
+            end_pos: node.loc.selector.end_pos
+          )
+
+          add_offense(new_perform_node) do |corrector|
+            corrector.replace(new_perform_node, 'perform_inline')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+# credit: https://github.com/dvandersluis/rubocop-sidekiq/blob/master/lib/rubocop/cop/sidekiq/symbol_argument.rb
+module RuboCop
+  module Cop
+    module Sidekiq
+      # This cop checks for symbols passed as arguments to a Sidekiq worker's perform method.
+      # Symbols cannot be properly serialized for Redis and should be avoided. Use strings instead.
+      #
+      # @example
+      #   # bad
+      #   MyWorker.perform_async(:foo)
+      #
+      #   # good
+      #   MyWorker.perform_async('foo')
+      class SymbolArgument < Base
+        include Helpers
+
+        MSG = 'Symbols are not Sidekiq-serializable; use strings instead.'
+
+        def on_send(node)
+          sidekiq_arguments(node).select(&:sym_type?).each do |argument|
+            add_offense(argument)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/petal/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Petal
-    VERSION = '1.3.1'
+    VERSION = '1.5.0'
   end
 end

data/lib/rubocop/petal.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'petal/version'
+require 'yaml'
 
 module RuboCop
   module Petal

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-petal
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Jean-Francis Bastien
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-13 00:00:00.000000000 Z
+date: 2024-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -96,6 +96,7 @@ files:
 - lib/rubocop-petal.rb
 - lib/rubocop/cop/chewy/field_type.rb
 - lib/rubocop/cop/chewy/reset_on_type.rb
+- lib/rubocop/cop/chewy/update_index_argument.rb
 - lib/rubocop/cop/grape/helpers_include_module.rb
 - lib/rubocop/cop/grape/prefer_namespace.rb
 - lib/rubocop/cop/grape/unnecessary_namespace.rb
@@ -116,13 +117,18 @@ 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/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/const_argument.rb
+- lib/rubocop/cop/sidekiq/date_time_argument.rb
+- lib/rubocop/cop/sidekiq/helpers.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/symbol_argument.rb
 - lib/rubocop/petal.rb
 - lib/rubocop/petal/inject.rb
 - lib/rubocop/petal/version.rb
@@ -150,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Petal custom cops

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Suggest to use authenticated_as instead of legacy api_key.
-      # It is faster, can be setup for multiple test.
-      #
-      #   # bad
-      #   get 'api/my_endpoint', headers: { HTTP_API_KEY: user.api_key }
-      #
-      #   # good
-      #   authenticated_as user
-      #   get 'api/my_endpoint'
-      #
-      class AuthenticatedAs < Base
-        MSG = 'Use `authenticated_as` instead of legacy api_key.'
-
-        def_node_search :use_header_api_key, <<~PATTERN
-          (sym :HTTP_API_KEY)
-        PATTERN
-
-        def on_send(node)
-          api_key_usage = use_header_api_key(node).to_a.first
-          return unless api_key_usage
-
-          add_offense(api_key_usage)
-        end
-      end
-    end
-  end
-end