rubocop-petal 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15da074670760958ac74e715caa688618632bcbb5379e5fc47dd1a1055c8e956
-  data.tar.gz: 0d70524ec6b85733e931c09c864151454cde3fc4287c87f6a1722d1d3c6ea81d
+  metadata.gz: 99a53e19d1caafc491f963ad3a723fb1b06f9e15fc9d0914db50287c68af1dd6
+  data.tar.gz: c1c37cbc85d3c4e56bdd2fffa928f8ce7f16db9afa5541014275a519d75146a5
 SHA512:
-  metadata.gz: 2271b3c9bdc14b033c248ec2b7492a2248e017c98a48daded7cee9621e4e5a42c5c30f8036b5c16fcd182408af56d6b213ee9c6a8f719c65506f913aac741b1e
-  data.tar.gz: 8780348f8074c78603b2fc8988297c12f4531080bd07f54af0cdaa4d9b63d021f5328b8e192b0c8cb34ee53d4933e3d04769240f6907e550a8e7c4e6e042f965
+  metadata.gz: 862c765c3e4c638372c04b441d569d25b260f0333e887cb25b76064ac82214173e4367b0225e4023b9ee4de9f804bb57b224bc524fb4beec46b9eff4bde8546d
+  data.tar.gz: 263fe7fd0120e188d681dd68f7f44533e01c32d0a71596bc064781628175c7a40f0acea5cb22ec00707a8a67917fdb1dda1ee6811fea92ebf1047887346da20a

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

@@ -55,12 +55,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 +126,26 @@ 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/SymbolArgument:
+  Description: "Prevent passing keywords arguments in worker's perform method"
+  Enabled: true

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

@@ -24,7 +24,9 @@ module RuboCop
               self.class.new(selectors + other.selectors)
             end
 
-            delegate :include?, to: :selectors
+            def include?(selector)
+              selectors.include?(selector)
+            end
 
             def block_pattern
               "(block #{send_pattern} ...)"

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/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.0'
+    VERSION = '1.4.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.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Jean-Francis Bastien
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-09 00:00:00.000000000 Z
+date: 2024-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -116,13 +116,17 @@ 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/symbol_argument.rb
 - lib/rubocop/petal.rb
 - lib/rubocop/petal/inject.rb
 - lib/rubocop/petal/version.rb
@@ -150,7 +154,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