rubocop-thread_safety 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdf9af170c6dcfe7ac085b6e68467551d4c14d1eac843fefb97f39645cf556a6
-  data.tar.gz: e6efe781ead225cbdcf14185a67851a57fa60fe0e31627342a7204eb5f656c3f
+  metadata.gz: c093be2fec5fa73fc90a6af37b1aece06ae43e02d079aef4ffb15948db8b3799
+  data.tar.gz: 640f785bc8cf61a88f87eda3fd806f775499bd517950b6f2c3e6dc79f7321d75
 SHA512:
-  metadata.gz: 18e2788dfc505506dd73e7231008200edca8c5055612442b14e6639ff362af00e4de983fc4be0980e6f3820a365175138cd7d04708ced0bf401db3c00eb429df
-  data.tar.gz: 94da6513c5ed7f1561f7e88385b3eddb6da8984127ac1da7e16f0a4c6c4c871390af0599b7b8c43c53bfc792af82363fdbe16b848fc7a93c6a10ea6d630e60d4
+  metadata.gz: 12f68444eaca92647816c292715a6a54af6d989b77c38619637e018817ad7dd990033defbf3ab64f7d9f51a85a1904096ac6ff6817befc77a5e2f73470061a2d
+  data.tar.gz: b9492879e05682caab54066a728d1eb386ff1ce83c713beb17cbb69f51cab0df8d561d5e594baa32204c426627be39674867f0b0574bbef015f8baac69886b3c

data/CHANGELOG.md

@@ -1,30 +1,48 @@
 # Change log
 
-## master
+## 0.8.0
+
+* [#112](https://github.com/rubocop/rubocop-thread_safety/pull/112): Speed up loading rubocop-thread_safety by lazily loading only the cops needed for a run. This requires RuboCop 1.89.0+. ([@koic][])
+* [#111](https://github.com/rubocop/rubocop-thread_safety/pull/111): Add new `ThreadSafety/EnvMutation` cop. ([@mikegee][])
+* [#109](https://github.com/rubocop/rubocop-thread_safety/pull/109): Add new `ThreadSafety/LazySynchronizationPrimitive` cop. ([@viralpraxis][])
+* [#107](https://github.com/rubocop/rubocop-thread_safety/pull/107): Add new `ThreadSafety/ActiveSupportCallbacks` cop. ([@mikegee][])
+* [#104](https://github.com/rubocop/rubocop-thread_safety/pull/104): Set minimum required RuboCop version to `1.81`. ([@viralpraxis][])
+* [#95](https://github.com/rubocop/rubocop-thread_safety/pull/95): Add new `ThreadSafety/MethodRedefinition` cop. ([@viralpraxis][])
+* [#91](https://github.com/rubocop/rubocop-thread_safety/pull/91): Make `ThreadSafety/MutableClassInstanceVariable` cop aware of `TestCase`'s `setup`/`teardown` DSL. ([@viralpraxis][])
+
+## 0.7.3
+
+* [#93](https://github.com/rubocop/rubocop-thread_safety/pull/93): Fix an error for `ThreadSafety/MutableClassInstanceVariable` cop. ([@viralpraxis][])
 
 ## 0.7.2
 
-- [#88](https://github.com/rubocop/rubocop-thread_safety/pull/88): Fix incorrect plugin metadata version. ([@viralpraxis](https://github.com/viralpraxis))
+* [#88](https://github.com/rubocop/rubocop-thread_safety/pull/88): Fix incorrect plugin metadata version. ([@viralpraxis][])
 
 ## 0.7.1
 
-- [#84](https://github.com/rubocop/rubocop-thread_safety/pull/84): Rename `InstanceVariableInClassMethod` in default config ([@sambostock](https://github.com/sambostock))
+* [#84](https://github.com/rubocop/rubocop-thread_safety/pull/84): Rename `InstanceVariableInClassMethod` in default config ([@sambostock][])
 
 ## 0.7.0
 
-- [#80](https://github.com/rubocop/rubocop-thread_safety/pull/80) Make RuboCop ThreadSafety work as a RuboCop plugin. ([@bquorning](https://github.com/bquorning))
-- [#76](https://github.com/rubocop/rubocop-thread_safety/pull/76): Detect offenses when using safe navigation for `ThreadSafety/DirChdir`, `ThreadSafety/NewThread` and `ThreadSafety/RackMiddlewareInstanceVariable` cops. ([@viralpraxis](https://github.com/viralpraxis))
-- [#73](https://github.com/rubocop/rubocop-thread_safety/pull/73): Add `AllowCallWithBlock` option to `ThreadSafety/DirChdir` cop. ([@viralpraxis](https://github.com/viralpraxis))
+* [#80](https://github.com/rubocop/rubocop-thread_safety/pull/80) Make RuboCop ThreadSafety work as a RuboCop plugin. ([@bquorning][])
+* [#76](https://github.com/rubocop/rubocop-thread_safety/pull/76): Detect offenses when using safe navigation for `ThreadSafety/DirChdir`, `ThreadSafety/NewThread` and `ThreadSafety/RackMiddlewareInstanceVariable` cops. ([@viralpraxis][])
+* [#73](https://github.com/rubocop/rubocop-thread_safety/pull/73): Add `AllowCallWithBlock` option to `ThreadSafety/DirChdir` cop. ([@viralpraxis][])
 
 ## 0.6.0
 
-* [#59](https://github.com/rubocop/rubocop-thread_safety/pull/59): Rename `ThreadSafety::InstanceVariableInClassMethod` cop to `ThreadSafety::ClassInstanceVariable` to better reflect its purpose. ([@viralpraxis](https://github.com/viralpraxis))
-* [#55](https://github.com/rubocop/rubocop-thread_safety/pull/55): Enhance `ThreadSafety::InstanceVariableInClassMethod` cop to detect offenses within `class_eval/exec` blocks. ([@viralpraxis](https://github.com/viralpraxis))
-* [#54](https://github.com/rubocop/rubocop-thread_safety/pull/54): Drop support for RuboCop older than 1.48. ([@viralpraxis](https://github.com/viralpraxis))
-* [#52](https://github.com/rubocop/rubocop-thread_safety/pull/52): Add new `RackMiddlewareInstanceVariable` cop to detect instance variables in Rack middleware. ([@viralpraxis](https://github.com/viralpraxis))
-* [#48](https://github.com/rubocop/rubocop-thread_safety/pull/48): Do not report instance variables in `ActionDispatch` callbacks in singleton methods. ([@viralpraxis](https://github.com/viralpraxis))
-* [#43](https://github.com/rubocop/rubocop-thread_safety/pull/43): Make detection of ActiveSupport's `class_attribute` configurable. ([@viralpraxis](https://github.com/viralpraxis))
-* [#42](https://github.com/rubocop/rubocop-thread_safety/pull/42): Fix some `InstanceVariableInClassMethod` cop false positive offenses. ([@viralpraxis](https://github.com/viralpraxis))
-* [#41](https://github.com/rubocop/rubocop-thread_safety/pull/41): Drop support for MRI older than 2.7. ([@viralpraxis](https://github.com/viralpraxis))
-* [#38](https://github.com/rubocop/rubocop-thread_safety/pull/38): Fix `NewThread` cop detection is case of `Thread.start`, `Thread.fork`, or `Thread.new` with arguments. ([@viralpraxis](https://github.com/viralpraxis))
-* [#36](https://github.com/rubocop/rubocop-thread_safety/pull/36): Add new `DirChdir` cop to detect `Dir.chdir` calls. ([@viralpraxis](https://github.com/viralpraxis))
+* [#59](https://github.com/rubocop/rubocop-thread_safety/pull/59): Rename `ThreadSafety::InstanceVariableInClassMethod` cop to `ThreadSafety::ClassInstanceVariable` to better reflect its purpose. ([@viralpraxis][])
+* [#55](https://github.com/rubocop/rubocop-thread_safety/pull/55): Enhance `ThreadSafety::InstanceVariableInClassMethod` cop to detect offenses within `class_eval/exec` blocks. ([@viralpraxis][])
+* [#54](https://github.com/rubocop/rubocop-thread_safety/pull/54): Drop support for RuboCop older than 1.48. ([@viralpraxis][])
+* [#52](https://github.com/rubocop/rubocop-thread_safety/pull/52): Add new `RackMiddlewareInstanceVariable` cop to detect instance variables in Rack middleware. ([@viralpraxis][])
+* [#48](https://github.com/rubocop/rubocop-thread_safety/pull/48): Do not report instance variables in `ActionDispatch` callbacks in singleton methods. ([@viralpraxis][])
+* [#43](https://github.com/rubocop/rubocop-thread_safety/pull/43): Make detection of ActiveSupport's `class_attribute` configurable. ([@viralpraxis][])
+* [#42](https://github.com/rubocop/rubocop-thread_safety/pull/42): Fix some `InstanceVariableInClassMethod` cop false positive offenses. ([@viralpraxis][])
+* [#41](https://github.com/rubocop/rubocop-thread_safety/pull/41): Drop support for MRI older than 2.7. ([@viralpraxis][])
+* [#38](https://github.com/rubocop/rubocop-thread_safety/pull/38): Fix `NewThread` cop detection is case of `Thread.start`, `Thread.fork`, or `Thread.new` with arguments. ([@viralpraxis][])
+* [#36](https://github.com/rubocop/rubocop-thread_safety/pull/36): Add new `DirChdir` cop to detect `Dir.chdir` calls. ([@viralpraxis][])
+
+[@bquorning]: https://github.com/bquorning
+[@koic]: https://github.com/koic
+[@mikegee]: https://github.com/mikegee
+[@sambostock]: https://github.com/sambostock
+[@viralpraxis]: https://github.com/viralpraxis

data/README.md

@@ -65,6 +65,10 @@ Improvements that would make shared state thread-safe include:
 
 Certain system calls, such as `chdir`, affect the entire process. To avoid potential thread-safety issues, it's preferable to use (if possible) the `chdir` option in methods like `Kernel.system` and `IO.popen` rather than relying on `Dir.chdir`.
 
+## Useful resources
+
+* Intro to thread-safety in Ruby by Socketry: https://socketry.github.io/async/guides/thread-safety/index.html
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/config/default.yml

@@ -2,6 +2,11 @@
 #
 # Without adding these to your rubocop config, these values will be the default.
 
+ThreadSafety/ActiveSupportCallbacks:
+  Description: 'Avoid mutating ActiveSupport callback chains at runtime.'
+  Enabled: pending
+  VersionAdded: '0.8'
+
 ThreadSafety/ClassAndModuleAttributes:
   Description: 'Avoid mutating class and module attributes.'
   Enabled: true
@@ -11,6 +16,18 @@ ThreadSafety/ClassInstanceVariable:
   Description: 'Avoid class instance variables.'
   Enabled: true
 
+ThreadSafety/MethodRedefinition:
+  Description: 'Do not use `remove_method` followed by method definition.'
+  Enabled: pending
+  VersionAdded: '0.8'
+  References:
+    - 'https://bugs.ruby-lang.org/issues/13574'
+
+ThreadSafety/LazySynchronizationPrimitive:
+  Description: 'Do not lazily initialize synchronization primitives with `||=`.'
+  Enabled: pending
+  VersionAdded: '0.8'
+
 ThreadSafety/MutableClassInstanceVariable:
   Description: 'Do not assign mutable objects to class instance variables.'
   Enabled: true
@@ -37,6 +54,11 @@ ThreadSafety/DirChdir:
   Enabled: true
   AllowCallWithBlock: false
 
+ThreadSafety/EnvMutation:
+  Description: Avoid mutating `ENV` due to its process-wide effect.
+  Enabled: false
+  VersionAdded: '0.8'
+
 ThreadSafety/RackMiddlewareInstanceVariable:
   Description: Avoid instance variables in Rack middleware.
   Enabled: true

data/lib/rubocop/cop/thread_safety/active_support_callbacks.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ThreadSafety
+      # Avoid mutating ActiveSupport callback chains at runtime.
+      #
+      # Calls such as `User.skip_callback` and `User.set_callback` mutate callback
+      # chains at process scope.
+      #
+      # @example
+      #   # bad
+      #   Site.skip_callback(:commit, :after, :after_owner_change)
+      #
+      #   # bad
+      #   Site.set_callback(
+      #     :commit, :after, :after_owner_change,
+      #     if: :saved_change_to_owner?
+      #   )
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     skip_callback :commit, :after, :after_owner_change
+      #   end
+      class ActiveSupportCallbacks < Base
+        requires_gem 'activesupport'
+
+        MSG = 'Avoid process-wide ActiveSupport callback mutation with `%<expression>s`.'
+        RESTRICT_ON_SEND = %i[set_callback skip_callback].freeze
+
+        def on_send(node)
+          return unless constant_receiver?(node.receiver)
+
+          add_offense(node.loc.selector, message: format(MSG, expression: callback_call(node)))
+        end
+        alias on_csend on_send
+
+        private
+
+        def constant_receiver?(receiver)
+          receiver = receiver.children.first while receiver&.begin_type? && receiver.children.one?
+
+          receiver&.const_type?
+        end
+
+        def callback_call(node)
+          "#{node.receiver.source}#{node.loc.dot.source}#{node.method_name}"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/thread_safety/class_instance_variable.rb

@@ -227,9 +227,9 @@ module RuboCop
         # @!method new_lexical_scope?(node)
         def_node_matcher :new_lexical_scope?, <<~PATTERN
           {
-            (block (send (const nil? :Struct) :new ...) _ ({def defs} ...))
-            (block (send (const nil? :Class) :new ...) _ ({def defs} ...))
-            (block (send (const nil? :Data) :define ...) _ ({def defs} ...))
+            (block (send (const nil? :Struct) :new ...) _ (any_def ...))
+            (block (send (const nil? :Class) :new ...) _ (any_def ...))
+            (block (send (const nil? :Data) :define ...) _ (any_def ...))
             (block
               (send nil?
                 {

data/lib/rubocop/cop/thread_safety/dir_chdir.rb

@@ -15,13 +15,13 @@ module RuboCop
       #   FileUtils.chdir("/var/run")
       #
       # @example AllowCallWithBlock: false (default)
-      #   # good
+      #   # bad
       #   Dir.chdir("/var/run") do
       #     puts Dir.pwd
       #   end
       #
       # @example AllowCallWithBlock: true
-      #   # bad
+      #   # good
       #   Dir.chdir("/var/run") do
       #     puts Dir.pwd
       #   end

data/lib/rubocop/cop/thread_safety/env_mutation.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ThreadSafety
+      # Avoid mutating `ENV`.
+      #
+      # Environment variables are process-wide. Mutating them can affect other
+      # threads, requests, jobs, or subprocesses running in the same Ruby
+      # process.
+      #
+      # @example
+      #   # bad
+      #   ENV['TZ'] = 'UTC'
+      #
+      #   # bad
+      #   ENV.update('FOO' => 'bar')
+      #
+      #   # good
+      #   system({ 'TZ' => 'UTC' }, 'date')
+      #
+      #   # good
+      #   ENV.fetch('TZ', 'UTC')
+      class EnvMutation < Base
+        MSG = 'Avoid mutating `ENV` due to its process-wide effect.'
+        RESTRICT_ON_SEND = %i[
+          []=
+          store
+          update
+          merge!
+          replace
+          delete
+          delete_if
+          reject!
+          keep_if
+          select!
+          filter!
+          shift
+          clear
+        ].freeze
+
+        # @!method env_mutation?(node)
+        def_node_matcher :env_mutation?, <<~PATTERN
+          (call
+            (const {nil? cbase} :ENV)
+            {
+              :[]=
+              :store
+              :update
+              :merge!
+              :replace
+              :delete
+              :delete_if
+              :reject!
+              :keep_if
+              :select!
+              :filter!
+              :shift
+              :clear
+            }
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless env_mutation?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/thread_safety/lazy_synchronization_primitive.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ThreadSafety
+      # Avoid lazily initializing synchronization primitives with `||=`.
+      #
+      # The check-then-set performed by `||=` is not atomic, so concurrent threads
+      # can observe an uninitialized primitive or create more than one instance.
+      # Eagerly assign the primitive (for example in `initialize`) or use a constant.
+      #
+      # @example
+      #   # bad
+      #   def mutex
+      #     @mutex ||= Mutex.new
+      #   end
+      #
+      #   # bad
+      #   def mutex = @mutex ||= Mutex.new
+      #
+      #   # good
+      #   def initialize
+      #     @mutex = Mutex.new
+      #   end
+      #
+      class LazySynchronizationPrimitive < Base
+        MSG = 'Do not lazily initialize synchronization primitives with `||=`.'
+
+        # @!method lazy_shared_variable_assignment?(node)
+        def_node_matcher :lazy_shared_variable_assignment?, <<~PATTERN
+          (or_asgn ${ivasgn cvasgn} _)
+        PATTERN
+
+        # @!method synchronization_primitive?(node)
+        def_node_matcher :synchronization_primitive?, <<~PATTERN
+          {
+            (send (const {nil? cbase} {:Mutex :Monitor}) :new ...)
+            (send (const (const nil? :Thread) :Mutex) :new ...)
+          }
+        PATTERN
+
+        def on_or_asgn(node)
+          return unless lazy_shared_variable_assignment?(node)
+          return unless synchronization_primitive?(node.rhs)
+          return unless method_definition?(node)
+          return if synchronized?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def method_definition?(node)
+          node.each_ancestor(:any_def).any?
+        end
+
+        def synchronized?(node)
+          node.each_ancestor(:block).any? do |ancestor|
+            ancestor.method?(:synchronize)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/thread_safety/method_redefinition.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ThreadSafety
+      # Avoid the thread-unsafe combination of remove_method followed by defining a method with the same name.
+      # This can lead to a race condition, as these two actions are not atomic.
+      # As a safer alternative, consider aliasing the method to itself instead.
+      #
+      # @example
+      #   # bad
+      #   remove_method :foo
+      #   def foo; end
+      #
+      #   # good
+      #   alias_method :foo, :foo
+      #   def foo; end
+      #
+      #   # good
+      #   alias foo foo
+      #   def foo; end
+      #
+      class MethodRedefinition < Base
+        MSG = 'Do not use `remove_method` followed by method definition.'
+
+        RESTRICT_ON_SEND = %i[remove_method].freeze
+
+        def on_send(node)
+          return unless (def_node = node.right_sibling)
+          return unless def_node.def_type?
+          return unless node.arguments.one?
+          return unless (method_name_node = node.first_argument).type?(:str, :sym)
+          return unless def_node.method?(method_name_node.value)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/thread_safety/mutable_class_instance_variable.rb

@@ -138,6 +138,8 @@ module RuboCop
         end
 
         def on_assignment(value)
+          return if within_dsl_with_threadsafe_semantics?(value)
+
           if style == :strict
             strict_check(value)
           else
@@ -194,7 +196,7 @@ module RuboCop
 
         def requires_parentheses?(node)
           range_type?(node) ||
-            (node.send_type? && node.loc.dot.nil?)
+            (node.send_type? && (node.loc.dot.nil? || (node.arguments.any? && !node.parenthesized_call?)))
         end
 
         def range_type?(node)
@@ -247,6 +249,18 @@ module RuboCop
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
           (begin (range _ _))
         PATTERN
+
+        # rubocop:disable-next Metrics
+        def within_dsl_with_threadsafe_semantics?(node)
+          return false unless node
+          return false unless (block_node = node.ancestors.find(&:block_type?))
+          return false unless block_node.method?(:setup) || block_node.method?(:teardown)
+
+          class_node = block_node.ancestors.find(&:class_type?)
+          return false unless class_node
+
+          class_node.parent_class&.const_name == 'ActiveSupport::TestCase'
+        end
       end
     end
   end

data/lib/rubocop/cop/thread_safety/rack_middleware_instance_variable.rb

@@ -113,7 +113,7 @@ module RuboCop
           constructor_method
             .each_node(:ivasgn)
             .select { |ivasgn_node| operation_produces_threadsafe_object?(ivasgn_node.to_a[1]) }
-            .map { _1.to_a[0] }
+            .map { |item| item.to_a[0] }
         end
       end
     end

data/lib/rubocop/cop/thread_safety.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'mixin/operation_with_threadsafe_result'
+
+module RuboCop
+  module Cop
+    # Cops for the `ThreadSafety` department. The department's cops are
+    # registered for lazy loading and their files are loaded on demand.
+    module ThreadSafety
+      extend LazyLoader
+
+      register_cop :ActiveSupportCallbacks, "#{__dir__}/thread_safety/active_support_callbacks"
+      register_cop :ClassInstanceVariable, "#{__dir__}/thread_safety/class_instance_variable"
+      register_cop :ClassAndModuleAttributes, "#{__dir__}/thread_safety/class_and_module_attributes"
+      register_cop :MutableClassInstanceVariable, "#{__dir__}/thread_safety/mutable_class_instance_variable"
+      register_cop :NewThread, "#{__dir__}/thread_safety/new_thread"
+      register_cop :DirChdir, "#{__dir__}/thread_safety/dir_chdir"
+      register_cop :EnvMutation, "#{__dir__}/thread_safety/env_mutation"
+      register_cop :RackMiddlewareInstanceVariable, "#{__dir__}/thread_safety/rack_middleware_instance_variable"
+      register_cop :MethodRedefinition, "#{__dir__}/thread_safety/method_redefinition"
+      register_cop :LazySynchronizationPrimitive, "#{__dir__}/thread_safety/lazy_synchronization_primitive"
+    end
+  end
+end

data/lib/rubocop/thread_safety/plugin.rb

@@ -6,7 +6,7 @@ module RuboCop
   module ThreadSafety
     # A plugin that integrates RuboCop ThreadSafety with RuboCop's plugin system.
     class Plugin < LintRoller::Plugin
-      # :nocov:
+      # simplecov:disable
       def about
         LintRoller::About.new(
           name: 'rubocop-thread_safety',
@@ -15,7 +15,7 @@ module RuboCop
           description: 'Thread-safety checks via static analysis.'
         )
       end
-      # :nocov:
+      # simplecov:enable
 
       def supported?(context)
         context.engine == :rubocop

data/lib/rubocop/thread_safety/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module ThreadSafety
     module Version
-      STRING = '0.7.2'
+      STRING = '0.8.0'
     end
   end
 end

data/lib/rubocop-thread_safety.rb

@@ -6,11 +6,4 @@ require 'rubocop/thread_safety'
 require 'rubocop/thread_safety/version'
 require 'rubocop/thread_safety/plugin'
 
-require 'rubocop/cop/mixin/operation_with_threadsafe_result'
-
-require 'rubocop/cop/thread_safety/class_instance_variable'
-require 'rubocop/cop/thread_safety/class_and_module_attributes'
-require 'rubocop/cop/thread_safety/mutable_class_instance_variable'
-require 'rubocop/cop/thread_safety/new_thread'
-require 'rubocop/cop/thread_safety/dir_chdir'
-require 'rubocop/cop/thread_safety/rack_middleware_instance_variable'
+require 'rubocop/cop/thread_safety'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-thread_safety
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Michael Gee
 bindir: exe
 cert_chain: []
-date: 2025-03-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lint_roller
@@ -29,20 +29,34 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.72'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: '1.89'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.72'
+        version: '1.89'
+- !ruby/object:Gem::Dependency
+  name: rubocop-ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: 1.44.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.44.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: |2
       Thread-safety checks via static analysis.
       A plugin for the RuboCop code style enforcing & linting tool.
@@ -59,9 +73,14 @@ files:
 - config/obsoletion.yml
 - lib/rubocop-thread_safety.rb
 - lib/rubocop/cop/mixin/operation_with_threadsafe_result.rb
+- lib/rubocop/cop/thread_safety.rb
+- lib/rubocop/cop/thread_safety/active_support_callbacks.rb
 - lib/rubocop/cop/thread_safety/class_and_module_attributes.rb
 - lib/rubocop/cop/thread_safety/class_instance_variable.rb
 - lib/rubocop/cop/thread_safety/dir_chdir.rb
+- lib/rubocop/cop/thread_safety/env_mutation.rb
+- lib/rubocop/cop/thread_safety/lazy_synchronization_primitive.rb
+- lib/rubocop/cop/thread_safety/method_redefinition.rb
 - lib/rubocop/cop/thread_safety/mutable_class_instance_variable.rb
 - lib/rubocop/cop/thread_safety/new_thread.rb
 - lib/rubocop/cop/thread_safety/rack_middleware_instance_variable.rb
@@ -91,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Thread-safety checks via static analysis
 test_files: []